Este el codigo del ejemplo
/////////////////////////////////////////////////////////////////////////
//// ////
//// RR2_USB_Cdc_Monitor.c ////
//// ////
/////////////////////////////////////////////////////////////////////////
#include <18F4550.h>
#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN
#use delay(clock=48000000)
#include ".\include\usb_cdc.h"
#rom int 0xf00000={1,2,3,4}
void main() {
BYTE i, j, address, value;
delay_ms(300);
usb_cdc_init();
usb_init();
while(!usb_cdc_connected()) {}
do {
usb_task();
if (usb_enumerated()) {
printf(usb_cdc_putc, "\r\n\nEEPROM:\r\n"); // Display contents of the first 64
for(i=0; i<=3; ++i) { // bytes of the data EEPROM in hex
for(j=0; j<=15; ++j) {
printf(usb_cdc_putc, "%2x ", read_eeprom( i*16+j ) );
}
printf(usb_cdc_putc, "\n\r");
}
printf(usb_cdc_putc, "\r\nLocation to change: ");
address = gethex_usb();
printf(usb_cdc_putc, "\r\nNew value: ");
value = gethex_usb();
write_eeprom( address, value );
}
} while (TRUE);
}
Y los includes que usa son 2, RedRaven les hizo unas minimas modificaciones
/////////////////////////////////////////////////////////////////////////
//// ////
//// usb_cdc.h ////
//// ////
//// Library for adding a virtual COM port on your PC over USB using ////
//// the standard Communication Device Class (CDC) specification. ////
//// Including this file in your code will add all USB code, ////
//// interrupts, descriptors and handlers required. No other ////
//// modifications need to be made. ////
//// ////
//// This library creates a virtual RS232 link between the PC and ////
//// the PIC, therefore the library provided will be familiar to ////
//// anyone with standard UART stream I/O: ////
//// ////
//// usb_cdc_kbhit() - Returns TRUE if there is one or more ////
//// character received and waiting in the receive buffer. ////
//// ////
//// usb_cdc_getc() - Gets a character from the receive buffer. If ////
//// there is no data in the receive buffer it will wait until ////
//// there is data in the receive buffer. If you do not want ////
//// to wait in an infinit loop, use usb_cdc_kbhit() first to ////
//// check if there is data before calling usb_cdc_getc(). ////
//// ////
//// usb_cdc_putc(char c) - Puts a character into the transmit ////
//// buffer. If the transmit buffer is full it will wait until ////
//// the transmit buffer is not full before putting the char ////
//// into the transmit buffer. The transmit buffer is read by ////
//// the PC very quickly, and therefore the buffer should only ////
//// be full for a few milli-seconds. If you are concerned ////
//// and don't want to be stuck in a long or infinite loop, ////
//// use usb_cdc_putready() to see if there is space in the ////
//// transmit buffer before putting data into the transmit ////
//// buffer. ////
//// ////
//// usb_cdc_putready() - Returns TRUE if there is room left in the ////
//// transmit buffer for another character. ////
//// ////
//// usb_cdc_connected() - Returns TRUE if we received a ////
//// Set_Line_Coding. On most serial terminal programs (such ////
//// as Hyperterminal), they will send a Set_Line_Coding ////
//// message when the program starts and it opens the virtual ////
//// COM port. This is a simple way to determine if the PC ////
//// is ready to display data on a serial terminal program, ////
//// but is not garaunteed to work all the time or on other ////
//// terminal programs. ////
//// ////
//// usb_cdc_putc_fast(char c) - Similar to usb_cdc_putc(), except ////
//// if the transmit buffer is full it will skip the char. ////
//// ////
//// usb_cdc_line_coding - A structure used for Set_Line_Coding and ////
//// Get_Line_Coding. Most of the time you can ignore this. ////
//// ////
//// usb_cdc_break - If the PC has sent a break command, this will ////
//// hold the break time (in milli-seconds). If the PC sends ////
//// a value of 0xFFFF the device is supposed to hold the ////
//// break until it sends a value of 0 ////
//// ////
//// usb_cdc_carrier - Where Set_Control_Line_State value is stored. ////
//// Of most relevance is the field dte_present, which is the ////
//// DTR setting. ////
//// ////
//// The following functions are also provided, and are ports of the ////
//// I/O functions in input.c. See input.c and the CCS manual for ////
//// documentation: ////
//// get_float_usb() - Read a float number from the user ////
//// get_long_usb() - Read a long number from the user ////
//// get_int_usb() - Read an integer number from the user ////
//// get_string_usb(char *s, int max) - Read a string from the user. ////
//// gethex_usb() - Read a byte, in HEX, from the user ////
//// gethex1_usb() - Read a HEX character ////
//// ////
//// This driver will load all the rest of the USB code, and a set ////
//// of descriptors that will properly describe a CDC device for a ////
//// virtual COM port (usb_desc_cdc.h) ////
//// ////
//// An .INF file is provided (cdc_NTXP.inf) that will load the ////
//// standard CDC drivers for a virtual COM port in Windows ////
//// NT/2000/XP and above. Unfortunately we do not provide an .inf ////
//// file for Windows 98 and ME. ////
//// ////
/////////////////////////////////////////////////////////////////////////
//// ////
//// VERSION HISTORY ////
//// ////
//// October 27th, 2005: Changed the way incoming packets are ////
//// handled in that CDC driver will not flush ////
//// endpoint until user has handled all data. This ////
//// will prevent overflows as the USB will NAK ////
//// incoming packets until it is ready to receive ////
//// more. ////
//// When using 18F4550 family, the RX buffer is ////
//// mapped directly to the endpoint buffer - this ////
//// saves a chunk of RAM. ////
//// When using the 18F4550 family, you can increase ////
//// the TX and RX size over 64 bytes. ////
//// No longer send 0len packets in the TBE interrupt. ////
//// Hopefully fixed bugs that caused random crashes ////
//// if you tried sending more than 64 bytes. ////
//// ////
//// July 6th, 2005: Global interrupts disabled when writing to TX ////
//// buffer. ////
//// ////
//// July 1st, 2005: Initial Release. ////
//// ////
/////////////////////////////////////////////////////////////////////////
//// (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. ////
/////////////////////////////////////////////////////////////////////////
//api for the user:
#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 ".\include\rr2_USB_Cdc_Monitor.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, 8);
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, 8);
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_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 >> 8) & 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 >> 8) & 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. [0] 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 8) ==7
0xD8,0x04, //vendor id (0x04D8 is Microchip)
0x0A,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)
'R',0,
'R',0,
'2',0,
//string 2 --> nombre del dispositivo
22, //length of string index
USB_DESC_STRING_TYPE, //descriptor type 0x03 (STRING)
'R',0,
'e',0,
'd',0,
'P',0,
'i',0,
'c',0,
' ',0,
'U',0,
'S',0,
'B',0
};
#ENDIF
MUCHAS GRACIAS
