Hola a todos, tengo el siguiente proble:
Estoy tratando de encender led por el puerto usb, y a la vez hago eco de lo que escribo, pero tengo un gran problema, cualquier tecla que presione me devuelve una "v" no me doy cuenta donde esta el error.
El puerto lo reconoce perfecto, la prueba es en una virtual con windos xp 32bits, pero me hace lo mismo en windows 7 64 bits.
Esta compilado en CCS 4.128
Aca esta el codigo fuente:
codigo .c
#include <18F4550.h>
#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN
#use delay(clock=48M)
#include "usb_cdc_prueba.h" // Descriptores del dispositivo USB.
//*********************** configuracion y declaraciones ****************
#define ledv PIN_B0 // asignando etiquetas a el pinb6
#define ledr PIN_B1
#define ledon output_high // asignando etiquetas a la funcion output
#define ledoff output_low
int8 data;
void main(){ // inicio del codigo
set_tris_d(0);
set_tris_b(0);
output_d(0);
//********* CONFIGURAR EL HOST Y VISUALIZAR MEDIANTE LEDS************//
ledoff(ledv); // enciendo el led rojo yq aun no detecta el host
ledon(ledr);
usb_cdc_init();
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
ledoff(ledr); // encendemos el led verde
ledon(ledv);
//************ TERMINA DE VISUALIZAR LOS LEDS ****************************//
///////////////////////////////////////////////////////////////////////////
// ************** INICIO DEL PROGRAMA *************************************
while(!usb_cdc_connected()){} // espera a detectar una transmisión de la PC (Set_Line_Coding).{}
while(true)
{
usb_task();
if(usb_enumerated()){ //retorna verdadero si el dispositivo esta enumerado
if(usb_cdc_kbhit()){ // en espera de un nuevo caracter en el buffer de recepcion
data=usb_cdc_getc();
if(data=='1'){ // ¿ llegó el caracter 1?
output_toggle(PIN_D7);} // Conmuta Led 1.
if(data=='2'){ // ¿ llegó el caracter 2?
output_toggle(PIN_D6);} // Conmuta Led 2.
if(data=='3'){ // ¿ llegó el caracter 3?
output_toggle(PIN_D5); } //Conmuta Led 3.
if(data=='4'){ // ¿ llegó el caracter 4?
output_toggle(PIN_D4);} // Conmuta Led 4.
if(data=='5'){ // ¿ llegó el caracter 5?
output_toggle(PIN_D3);} // Conmuta Led 5.
if(data=='6'){ // ¿ llegó el caracter 6?
output_toggle(PIN_D2);} //Conmuta Led 6.
if(data=='7'){ // ¿ llegó el caracter 7?
output_toggle(PIN_D1);} // Conmuta Led7.
if(data=='8'){ // ¿ llegó el caracter8?
output_toggle(PIN_D0);} // Conmuta Led 8.
if(data=='9'){ // ¿ llegó el caracter 9?
output_d(0); } // apaga todo
if(data=='a'){ // ¿l llegó el caracter a?
output_d(255); } // prende todo
printf(usb_cdc_putc,"valor: %c \n\r",data);
}
}
}
}
usb_cdc_prueba.h
#define usb_cdc_kbhit() (usb_cdc_get_buffer_status.got)
#define usb_cdc_putready() (usb_cdc_put_buffer_nextin<USB_CDC_DATA_IN_SIZE)
#define usb_cdc_connected() (usb_cdc_got_set_line_coding)
void usb_cdc_putc_fast(char c);
char usb_cdc_getc(void);
void usb_cdc_putc(char c);
//input.c ported to use CDC:
float get_float_usb();
signed long get_long_usb();
signed int get_int_usb();
void get_string_usb(char* s, int max);
BYTE gethex_usb();
BYTE gethex1_usb();
//functions automatically called by USB handler code
void usb_isr_tkn_cdc(void);
void usb_cdc_init(void);
void usb_isr_tok_out_cdc_control_dne(void);
void usb_isr_tok_in_cdc_data_dne(void);
void usb_isr_tok_out_cdc_data_dne(void);
void usb_cdc_flush_out_buffer(void);
//Tells the CCS PIC USB firmware to include HID handling code.
#DEFINE USB_HID_DEVICE FALSE
#DEFINE USB_CDC_DEVICE TRUE
#define USB_CDC_COMM_IN_ENDPOINT 1
#define USB_CDC_COMM_IN_SIZE 8
#define USB_EP1_TX_ENABLE USB_ENABLE_INTERRUPT
#define USB_EP1_TX_SIZE USB_CDC_COMM_IN_SIZE
//pic to pc endpoint config
#define USB_CDC_DATA_IN_ENDPOINT 2
#define USB_CDC_DATA_IN_SIZE 64
#define USB_EP2_TX_ENABLE USB_ENABLE_BULK
#define USB_EP2_TX_SIZE USB_CDC_DATA_IN_SIZE
//pc to pic endpoint config
#define USB_CDC_DATA_OUT_ENDPOINT 2
#define USB_CDC_DATA_OUT_SIZE 64
#define USB_EP2_RX_ENABLE USB_ENABLE_BULK
#define USB_EP2_RX_SIZE USB_CDC_DATA_OUT_SIZE
/////////////////////////////////////////////////////////////////////////////
//
// Include the CCS USB Libraries. See the comments at the top of these
// files for more information
//
/////////////////////////////////////////////////////////////////////////////
#ifndef __USB_PIC_PERIF__
#define __USB_PIC_PERIF__ 1
#endif
#if __USB_PIC_PERIF__
#if defined(__PCM__)
#error CDC requires bulk mode! PIC16C7x5 does not have bulk mode
#else
#include <pic18_usb.h> //Microchip 18Fxx5x hardware layer for usb.c
#endif
#else
#include <usbn960x.c> //National 960x hardware layer for usb.c
#endif
#include "usb_cdc_prueba2.h" //USB Configuration and Device descriptors for this UBS device
#include <usb.c> //handles usb setup tokens and get descriptor reports
struct {
int32 dwDTERrate; //data terminal rate, in bits per second
int8 bCharFormat; //num of stop bits (0=1, 1=1.5, 2=2)
int8 bParityType; //parity (0=none, 1=odd, 2=even, 3=mark, 4=space)
int8 bDataBits; //data bits (5,6,7,8 or 16)
} usb_cdc_line_coding;
//length of time, in ms, of break signal as we received in a SendBreak message.
//if ==0xFFFF, send break signal until we receive a 0x0000.
int16 usb_cdc_break;
int8 usb_cdc_encapsulated_cmd[8];
int8 usb_cdc_put_buffer[USB_CDC_DATA_IN_SIZE];
int1 usb_cdc_put_buffer_free;
#if USB_CDC_DATA_IN_SIZE>=0x100
int16 usb_cdc_put_buffer_nextin=0;
// int16 usb_cdc_last_data_packet_size;
#else
int8 usb_cdc_put_buffer_nextin=0;
// int8 usb_cdc_last_data_packet_size;
#endif
struct {
int1 got;
#if USB_CDC_DATA_OUT_SIZE>=0x100
int16 len;
int16 index;
#else
int8 len;
int8 index;
#endif
} usb_cdc_get_buffer_status;
int8 usb_cdc_get_buffer_status_buffer[USB_CDC_DATA_OUT_SIZE];
#if (defined(__PIC__))
#if __PIC__
//#locate usb_cdc_get_buffer_status_buffer=0x500+(2*USB_MAX_EP0_PACKET_LENGTH)+USB_CDC_COMM_IN_SIZE
#if USB_MAX_EP0_PACKET_LENGTH==8
#locate usb_cdc_get_buffer_status_buffer=0x500+24
#elif USB_MAX_EP0_PACKET_LENGTH==64
#locate usb_cdc_get_buffer_status_buffer=0x500+136
#else
#error CCS BUG WONT LET ME USE MATH IN LOCATE
#endif
#endif
#endif
int1 usb_cdc_got_set_line_coding;
struct {
int1 dte_present; //1=DTE present, 0=DTE not present
int1 active; //1=activate carrier, 0=deactivate carrier
int reserved:6;
} usb_cdc_carrier;
enum {USB_CDC_OUT_NOTHING=0, USB_CDC_OUT_COMMAND=1, USB_CDC_OUT_LINECODING=2, USB_CDC_WAIT_0LEN=3} __usb_cdc_state=0;
#byte INTCON=0xFF2
#bit INT_GIE=INTCON.7
//handle OUT token done interrupt on endpoint 0 [read encapsulated cmd and line coding data]
void usb_isr_tok_out_cdc_control_dne(void) {
debug_usb(debug_putc,"CDC %X ",__usb_cdc_state);
switch (__usb_cdc_state) {
//printf(putc_tbe,"@%X@\r\n", __usb_cdc_state);
case USB_CDC_OUT_COMMAND:
//usb_get_packet(0, usb_cdc_encapsulated_cmd,
;
memcpy(usb_cdc_encapsulated_cmd, usb_ep0_rx_buffer,8);
#if USB_MAX_EP0_PACKET_LENGTH==8
__usb_cdc_state=USB_CDC_WAIT_0LEN;
usb_request_get_data();
#else
usb_put_0len_0();
__usb_cdc_state=0;
#endif
break;
#if USB_MAX_EP0_PACKET_LENGTH==8
case USB_CDC_WAIT_0LEN:
usb_put_0len_0();
__usb_cdc_state=0;
break;
#endif
case USB_CDC_OUT_LINECODING:
//usb_get_packet(0, &usb_cdc_line_coding, 7);
//printf(putc_tbe,"\r\n!GSLC FIN!\r\n");
memcpy(&usb_cdc_line_coding, usb_ep0_rx_buffer,7);
__usb_cdc_state=0;
usb_put_0len_0();
break;
default:
__usb_cdc_state=0;
usb_init_ep0_setup();
break;
}
}
//handle IN token on 0 (setup packet)
void usb_isr_tkn_cdc(void) {
//make sure the request goes to a CDC interface
if ((usb_ep0_rx_buffer[4] == 1) || (usb_ep0_rx_buffer[4] == 0)) {
//printf(putc_tbe,"!%X!\r\n", usb_ep0_rx_buffer[1]);
switch(usb_ep0_rx_buffer[1]) {
case 0x00: //send_encapsulated_command
__usb_cdc_state=USB_CDC_OUT_COMMAND;
usb_request_get_data();
break;
case 0x01: //get_encapsulated_command
memcpy(usb_ep0_tx_buffer, usb_cdc_encapsulated_cmd,
;
usb_request_send_response(usb_ep0_rx_buffer[6]); //send wLength bytes
break;
case 0x20: //set_line_coding
debug_usb(debug_putc,"!GSLC!");
__usb_cdc_state=USB_CDC_OUT_LINECODING;
usb_cdc_got_set_line_coding=TRUE;
usb_request_get_data();
break;
case 0x21: //get_line_coding
memcpy(usb_ep0_tx_buffer, &usb_cdc_line_coding, sizeof(usb_cdc_line_coding));
usb_request_send_response(sizeof(usb_cdc_line_coding)); //send wLength bytes
break;
case 0x22: //set_control_line_state
usb_cdc_carrier=usb_ep0_rx_buffer[2];
usb_put_0len_0();
break;
case 0x23: //send_break
usb_cdc_break=make16(usb_ep0_rx_buffer[2],usb_ep0_rx_buffer[3]);
usb_put_0len_0();
break;
default:
usb_request_stall();
break;
}
}
}
//handle OUT token done interrupt on endpoint 3 [buffer incoming received chars]
void usb_isr_tok_out_cdc_data_dne(void) {
usb_cdc_get_buffer_status.got=TRUE;
usb_cdc_get_buffer_status.index=0;
#if (defined(__PIC__))
#if __PIC__
usb_cdc_get_buffer_status.len=usb_rx_packet_size(USB_CDC_DATA_OUT_ENDPOINT);
#else
usb_cdc_get_buffer_status.len=usb_get_packet_buffer(
USB_CDC_DATA_OUT_ENDPOINT,&usb_cdc_get_buffer_status_buffer[0],USB_CDC_DATA_OUT_SIZE);
#endif
#else
usb_cdc_get_buffer_status.len=usb_get_packet_buffer(
USB_CDC_DATA_OUT_ENDPOINT,&usb_cdc_get_buffer_status_buffer[0],USB_CDC_DATA_OUT_SIZE);
#endif
}
//handle IN token done interrupt on endpoint 2 [transmit buffered characters]
void usb_isr_tok_in_cdc_data_dne(void) {
if (usb_cdc_put_buffer_nextin) {
usb_cdc_flush_out_buffer();
}
//send a 0len packet if needed
// else if (usb_cdc_last_data_packet_size==USB_CDC_DATA_IN_SIZE) {
// usb_cdc_last_data_packet_size=0;
// printf(putc_tbe, "FL 0\r\n");
// usb_put_packet(USB_CDC_DATA_IN_ENDPOINT,0,0,USB_DTS_TOGGLE);
// }
else {
usb_cdc_put_buffer_free=TRUE;
//printf(putc_tbe, "FL DONE\r\n");
}
}
void usb_cdc_flush_out_buffer(void) {
if (usb_cdc_put_buffer_nextin) {
usb_cdc_put_buffer_free=FALSE;
//usb_cdc_last_data_packet_size=usb_cdc_put_buffer_nextin;
//printf(putc_tbe, "FL %U\r\n", usb_cdc_put_buffer_nextin);
usb_put_packet(USB_CDC_DATA_IN_ENDPOINT,usb_cdc_put_buffer,usb_cdc_put_buffer_nextin,USB_DTS_TOGGLE);
usb_cdc_put_buffer_nextin=0;
}
}
void usb_cdc_init(void) {
usb_cdc_line_coding.dwDTERrate=9600;
usb_cdc_line_coding.bCharFormat=0;
usb_cdc_line_coding.bParityType=0;
usb_cdc_line_coding.bDataBits=8;
(int8)usb_cdc_carrier=0;
usb_cdc_got_set_line_coding=FALSE;
usb_cdc_break=0;
usb_cdc_put_buffer_nextin=0;
usb_cdc_get_buffer_status.got=0;
usb_cdc_put_buffer_free=TRUE;
}
////////////////// END USB CONTROL HANDLING //////////////////////////////////
////////////////// BEGIN USB<->RS232 CDC LIBRARY /////////////////////////////
char usb_cdc_getc(void) {
char c;
while (!usb_cdc_kbhit()) {}
c=usb_cdc_get_buffer_status_buffer[usb_cdc_get_buffer_status.index++];
if (usb_cdc_get_buffer_status.index >= usb_cdc_get_buffer_status.len) {
usb_cdc_get_buffer_status.got=FALSE;
usb_flush_out(USB_CDC_DATA_OUT_ENDPOINT, USB_DTS_TOGGLE);
}
return(c);
}
void usb_cdc_putc_fast(char c) {
int1 old_gie;
//disable global interrupts
old_gie=INT_GIE;
INT_GIE=0;
if (usb_cdc_put_buffer_nextin >= USB_CDC_DATA_IN_SIZE) {
usb_cdc_put_buffer_nextin=USB_CDC_DATA_IN_SIZE-1; //we just overflowed the buffer!
}
usb_cdc_put_buffer[usb_cdc_put_buffer_nextin++]=c;
//renable global interrupts
INT_GIE=old_gie;
/*
if (usb_tbe(USB_CDC_DATA_IN_ENDPOINT)) {
if (usb_cdc_put_buffer_nextin)
usb_cdc_flush_out_buffer();
}
*/
if (usb_cdc_put_buffer_free) {
usb_cdc_flush_out_buffer();
}
}
void usb_cdc_putc(char c) {
while (!usb_cdc_putready()) {
if (usb_cdc_put_buffer_free) {
usb_cdc_flush_out_buffer();
}
//delay_ms(500);
//printf(putc_tbe,"TBE=%U CNT=%U LST=%U\r\n",usb_tbe(USB_CDC_DATA_IN_ENDPOINT), usb_cdc_put_buffer_nextin, usb_cdc_last_data_packet_size);
}
usb_cdc_putc_fast(c);
}
#include <ctype.h>
BYTE gethex1_usb() {
char digit;
digit = usb_cdc_getc();
usb_cdc_putc(digit);
if(digit<='9')
return(digit-'0');
else
return((toupper(digit)-'A')+10);
}
BYTE gethex_usb() {
int lo,hi;
hi = gethex1_usb();
lo = gethex1_usb();
if(lo==0xdd)
return(hi);
else
return( hi*16+lo );
}
void get_string_usb(char* s, int max) {
int len;
char c;
--max;
len=0;
do {
c=usb_cdc_getc();
if(c==8) { // Backspace
if(len>0) {
len--;
usb_cdc_putc(c);
usb_cdc_putc(' ');
usb_cdc_putc(c);
}
} else if ((c>=' ')&&(c<='~'))
if(len<max) {
s[len++]=c;
usb_cdc_putc(c);
}
} while(c!=13);
s[len]=0;
}
// stdlib.h is required for the ato_ conversions
// in the following functions
#ifdef _STDLIB
signed int get_int_usb() {
char s[5];
signed int i;
get_string_usb(s, 5);
i=atoi(s);
return(i);
}
signed long get_long_usb() {
char s[7];
signed long l;
get_string_usb(s, 7);
l=atol(s);
return(l);
}
float get_float_usb() {
char s[20];
float f;
get_string_usb(s, 20);
f = atof(s);
return(f);
}
#endif
usb_cdc_prueba2.h
///////////////////////////////////////////////////////////////////////////
//// usb_desc_cdc.h ////
//// ////
//// An example set of device / configuration descriptors for use with ////
//// CCS's CDC Virtual COM Port driver (see usb_cdc.h) ////
//// ////
//// Two examples are provided: ////
//// ex_usb_serial.c ////
//// ex_usb_serial2.c ////
//// ////
///////////////////////////////////////////////////////////////////////////
//// ////
//// Version History: ////
//// ////
//// 10/28/05: ////
//// Bulk endpoint sizes updated to allow more than 255 byte ////
//// packets. ////
//// Changed device to USB 1.10 ////
//// ////
///////////////////////////////////////////////////////////////////////////
//// (C) Copyright 1996,2005 Custom Computer Services ////
//// This source code may only be used by licensed users of the CCS ////
//// C compiler. This source code may only be distributed to other ////
//// licensed users of the CCS C compiler. No other use, ////
//// reproduction or distribution is permitted without written ////
//// permission. Derivative programs created using this software ////
//// in object code form are not restricted in any way. ////
///////////////////////////////////////////////////////////////////////////
#IFNDEF __USB_DESCRIPTORS__
#DEFINE __USB_DESCRIPTORS__
#include <usb.h>
//////////////////////////////////////////////////////////////////
///
/// start config descriptor
/// right now we only support one configuration descriptor.
/// the config, interface, class, and endpoint goes into this array.
///
//////////////////////////////////////////////////////////////////
#DEFINE USB_TOTAL_CONFIG_LEN 67 //config+interface+class+endpoint+endpoint (2 endpoints)
const char USB_CONFIG_DESC[] = {
//IN ORDER TO COMPLY WITH WINDOWS HOSTS, THE ORDER OF THIS ARRAY MUST BE:
// config(s)
// interface(s)
// class(es)
// endpoint(s)
//config_descriptor for config index 1
USB_DESC_CONFIG_LEN, //length of descriptor size ==0
USB_DESC_CONFIG_TYPE, //constant CONFIGURATION (CONFIGURATION 0x02) ==1
USB_TOTAL_CONFIG_LEN,0, //size of all data returned for this config ==2,3
2, //number of interfaces this device supports ==4
0x01, //identifier for this configuration. (IF we had more than one configurations) ==5
0x00, //index of string descriptor for this configuration ==6
0xC0, //bit 6=1 if self powered, bit 5=1 if supports remote wakeup (we don't), bits 0-4 unused and bit7=1 ==7
0x32, //maximum bus power required (maximum milliamperes/2) (0x32 = 100mA) ==8
//interface descriptor 0 (comm class interface)
USB_DESC_INTERFACE_LEN, //length of descriptor =9
USB_DESC_INTERFACE_TYPE, //constant INTERFACE (INTERFACE 0x04) =10
0x00, //number defining this interface (IF we had more than one interface) ==11
0x00, //alternate setting ==12
1, //number of endpoints ==13
0x02, //class code, 02 = Comm Interface Class ==14
0x02, //subclass code, 2 = Abstract ==15
0x01, //protocol code, 1 = v.25ter ==16
0x00, //index of string descriptor for interface ==17
//class descriptor [functional header]
5, //length of descriptor ==18
0x24, //dscriptor type (0x24 == ) ==19
0, //sub type (0=functional header) ==20
0x10,0x01, // ==21,22 //cdc version
//class descriptor [acm header]
4, //length of descriptor ==23
0x24, //dscriptor type (0x24 == ) ==24
2, //sub type (2=ACM) ==25
2, //capabilities ==26 //we support Set_Line_Coding, Set_Control_Line_State, Get_Line_Coding, and the notification Serial_State.
//class descriptor [union header]
5, //length of descriptor ==27
0x24, //dscriptor type (0x24 == ) ==28
6, //sub type (6=union) ==29
0, //master intf ==30 //The interface number of the Communication or Dat a Cl ass interface, designated as the masteror controlling interface for the union.
1, //save intf0 ==31 //Interface number of first slave or associated interface in the union. *
//class descriptor [call mgmt header]
5, //length of descriptor ==32
0x24, //dscriptor type (0x24 == ) ==33
1, //sub type (1=call mgmt) ==34
0, //capabilities ==35 //device does not handle call management itself
1, //data interface ==36 //interface number of data class interface
//endpoint descriptor
USB_DESC_ENDPOINT_LEN, //length of descriptor ==37
USB_DESC_ENDPOINT_TYPE, //constant ENDPOINT (ENDPOINT 0x05) ==38
USB_CDC_COMM_IN_ENDPOINT | 0x80, //endpoint number and direction
0x03, //transfer type supported (0x03 is interrupt) ==40
USB_CDC_COMM_IN_SIZE,0x00, //maximum packet size supported ==41,42
250, //polling interval, in ms. (cant be smaller than 10) ==43
//interface descriptor 1 (data class interface)
USB_DESC_INTERFACE_LEN, //length of descriptor =44
USB_DESC_INTERFACE_TYPE, //constant INTERFACE (INTERFACE 0x04) =45
0x01, //number defining this interface (IF we had more than one interface) ==46
0x00, //alternate setting ==47
2, //number of endpoints ==48
0x0A, //class code, 0A = Data Interface Class ==49
0x00, //subclass code ==50
0x00, //protocol code ==51
0x00, //index of string descriptor for interface ==52
//endpoint descriptor
USB_DESC_ENDPOINT_LEN, //length of descriptor ==60
USB_DESC_ENDPOINT_TYPE, //constant ENDPOINT (ENDPOINT 0x05) ==61
USB_CDC_DATA_OUT_ENDPOINT, //endpoint number and direction (0x02 = EP2 OUT) ==62
0x02, //transfer type supported (0x02 is bulk) ==63
// make8(USB_CDC_DATA_OUT_SIZE,0),make8(USB_CDC_DATA_OUT_SIZE,1), //maximum packet size supported ==64, 65
USB_CDC_DATA_OUT_SIZE & 0xFF, (USB_CDC_DATA_OUT_SIZE >>
& 0xFF, //maximum packet size supported ==64, 65
250, //polling interval, in ms. (cant be smaller than 10) ==66
//endpoint descriptor
USB_DESC_ENDPOINT_LEN, //length of descriptor ==53
USB_DESC_ENDPOINT_TYPE, //constant ENDPOINT (ENDPOINT 0x05) ==54
USB_CDC_DATA_IN_ENDPOINT | 0x80, //endpoint number and direction (0x82 = EP2 IN) ==55
0x02, //transfer type supported (0x02 is bulk) ==56
// make8(USB_CDC_DATA_IN_SIZE,0),make8(USB_CDC_DATA_IN_SIZE,1), //maximum packet size supported ==57, 58
USB_CDC_DATA_IN_SIZE & 0xFF, (USB_CDC_DATA_IN_SIZE >>
& 0xFF, //maximum packet size supported ==64, 65
250, //polling interval, in ms. (cant be smaller than 10) ==59
};
//****** BEGIN CONFIG DESCRIPTOR LOOKUP TABLES ********
//since we can't make pointers to constants in certain pic16s, this is an offset table to find
// a specific descriptor in the above table.
//the maximum number of interfaces seen on any config
//for example, if config 1 has 1 interface and config 2 has 2 interfaces you must define this as 2
#define USB_MAX_NUM_INTERFACES 2
//define how many interfaces there are per config.
- is the first config, etc.
const char USB_NUM_INTERFACES[USB_NUM_CONFIGURATIONS]={2};
//define where to find class descriptors
//first dimension is the config number
//second dimension specifies which interface
//last dimension specifies which class in this interface to get, but most will only have 1 class per interface
//if a class descriptor is not valid, set the value to 0xFFFF
const int16 USB_CLASS_DESCRIPTORS[USB_NUM_CONFIGURATIONS][USB_MAX_NUM_INTERFACES][4]=
{
//config 1
//interface 0
//class 1-4
18,23,27,32,
//interface 1
//no classes for this interface
0xFFFF,0xFFFF,0xFFFF,0xFFFF
};
#if (sizeof(USB_CONFIG_DESC) != USB_TOTAL_CONFIG_LEN)
#error USB_TOTAL_CONFIG_LEN not defined correctly
#endif
//////////////////////////////////////////////////////////////////
///
/// start device descriptors
///
//////////////////////////////////////////////////////////////////
const char USB_DEVICE_DESC[USB_DESC_DEVICE_LEN] ={
//starts of with device configuration. only one possible
USB_DESC_DEVICE_LEN, //the length of this report ==0
0x01, //the constant DEVICE (DEVICE 0x01) ==1
0x10,0x01, //usb version in bcd ==2,3
0x02, //class code. 0x02=Communication Device Class ==4
0x00, //subclass code ==5
0x00, //protocol code ==6
USB_MAX_EP0_PACKET_LENGTH, //max packet size for endpoint 0. (SLOW SPEED SPECIFIES
==7
0x61,0x04, //vendor id (0x04D8 is Microchip)
0x33,0x00, //product id
// RR2 cambiado para 0x61,0x04, //vendor id (0x04D8 is Microchip, or is it 0x0461 ??) ==8,9
// compatibilidad con .inf 0x33,0x00, //product id ==10,11
// de Microchip
0x00,0x01, //device release number ==12,13
0x01, //index of string description of manufacturer. therefore we point to string_1 array (see below) ==14
0x02, //index of string descriptor of the product ==15
0x00, //index of string descriptor of serial number ==16
USB_NUM_CONFIGURATIONS //number of possible configurations ==17
};
//////////////////////////////////////////////////////////////////
///
/// start string descriptors
/// String 0 is a special language string, and must be defined. People in U.S.A. can leave this alone.
///
/// You must define the length else get_next_string_character() will not see the string
/// Current code only supports 10 strings (0 thru 9)
///
//////////////////////////////////////////////////////////////////
//the offset of the starting location of each string. offset[0] is the start of string 0, offset[1] is the start of string 1, etc.
char USB_STRING_DESC_OFFSET[]={0,4,12};
char const USB_STRING_DESC[]={
//string 0
4, //length of string index
USB_DESC_STRING_TYPE, //descriptor type 0x03 (STRING)
0x09,0x04, //Microsoft Defined for US-English
//string 1
8, //length of string index
USB_DESC_STRING_TYPE, //descriptor type 0x03 (STRING)
'c',0,
'c',0,
'2',0,
//string 2 --> nombre del dispositivo
22, //length of string index
USB_DESC_STRING_TYPE, //descriptor type 0x03 (STRING)
'p',0,
'e',0,
'p',0,
'e',0,
'i',0,
'c',0,
' ',0,
'U',0,
'S',0,
'B',0
};
#ENDIF
