Te mando el código de un programa simple de comunicacíon PIC-PC. Las funciones de USB que se utilizan son muy pocas:
-usb_init_cs();
-usb_task();
-usb_enumerated();
-usb_get_packet();
-usb_put_packet();
Al programa del PC tienes que darle los valores de Vendor y Product.
Espero que te sirva, aunque está hecho para un PIC 18F2550 creo que te puede servir.
Saludos,
Miquel
/*******************************************************************************
SetUp:
/*030
0 > 0 sin eco 1 con eco
3 > 0=1200 1=2400 2=4800 3=9600 4=19200 5=38400 6=57600 7=115200
Por defecto= Sin eco,9600
Vendor >> 0x61,0x04 (1121) , //vendor id (0x04D8 is Microchip, or is it 0x0461 ??)
Product >> 0x20,0x00 (32)
*******************************************************************************/
#include <18F2550.h>
#device adc=10
#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN,NOPBADEN
#use delay(clock=48000000)
#use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8,stream=PORT1)
#define USB_HID_DEVICE TRUE
#define USB_EP1_TX_ENABLE USB_ENABLE_INTERRUPT
#define USB_EP1_TX_SIZE 64 // 8
#define USB_EP1_RX_ENABLE USB_ENABLE_INTERRUPT
#define USB_EP1_RX_SIZE 64 // 8
#include <pic18_usb.h>
#include <usb_desc_hid_perla.h>
#include <usb.c>
#define OERR_BIT 1 // Bit OERR del registro RCSTA
#define CREN_BIT 4 // Bit CREN del registro RCSTA
#byte RCSTA = 0x18 // Registro RCSTA
void TestComando(void);
void SetBuffer(Char c);
unsigned int8 data_in[USB_EP1_RX_SIZE];
unsigned int8 data_out[USB_EP1_TX_SIZE];
char Buffer[USB_EP1_TX_SIZE];
int8 Cont=0;
int1 Eco=FALSE;
void main()
{
char C;
set_tris_b(0x00);
output_high(PIN_B0);
usb_init_cs();
delay_ms(500);
output_low(PIN_B0);
While (kbhit()) C=getc();
bit_clear(RCSTA,CREN_BIT);
delay_us(50);
bit_set(RCSTA,CREN_BIT);
while(TRUE)
{
usb_task();
if (usb_enumerated())
{
if (usb_kbhit(1))
{
usb_get_packet(1,data_in,USB_EP1_RX_SIZE);
TestComando();
}
}
if (kbhit())
{
C=getc();
SetBuffer(C);
}
}
}
void SetBuffer(Char c)
{
if (c >= 32) Buffer[Cont++]=c;
else if (c == 13)
{
Buffer[Cont]=0;
Cont=0;
sprintf(data_out,"%s",Buffer);
if (usb_enumerated()) usb_put_packet(1,data_out,USB_EP1_TX_SIZE,USB_DTS_TOGGLE);
if (Eco) printf(">>>%s\r\n",Buffer);
}
if (Cont >= (USB_EP1_TX_SIZE - 1)) Cont=0;
}
void TestComando(void)
{
if ((data_in[0] == '/') && (data_in[1] == '*'))
{
if (data_in[2] == '1') Eco=TRUE;
else Eco=FALSE;
if (data_in[3] == '0') set_uart_speed(1200,PORT1);
else if (data_in[3] == '1') set_uart_speed(2400,PORT1);
else if (data_in[3] == '2') set_uart_speed(4800,PORT1);
else if (data_in[3] == '3') set_uart_speed(9600,PORT1);
else if (data_in[3] == '4') set_uart_speed(19200,PORT1);
else if (data_in[3] == '5') set_uart_speed(38400,PORT1);
else if (data_in[3] == '6') set_uart_speed(57600,PORT1);
else if (data_in[3] == '7') set_uart_speed(115200,PORT1);
else setup_uart(9600,PORT1);
sprintf(data_in,">>>SET OK");
usb_put_packet(1,data_in,USB_EP1_TX_SIZE,USB_DTS_TOGGLE);
bit_clear(RCSTA,CREN_BIT);
delay_us(50);
bit_set(RCSTA,CREN_BIT);
}
else
{
printf("%s",data_in);
if (Eco)
{
sprintf(data_out,">>>%s",data_in);
usb_put_packet(1,data_out,USB_EP1_TX_SIZE,USB_DTS_TOGGLE);
}
}
}
Librería: #include <usb_desc_hid_perla.h>
#IFNDEF __USB_DESCRIPTORS__
#DEFINE __USB_DESCRIPTORS__
#include <usb.h>
//////////////////////////////////////////////////////////////////
///
/// HID Report. Tells HID driver how to handle and deal with
/// received data. HID Reports can be extremely complex,
/// see HID specifcation for help on writing your own.
///
/// CCS example uses a vendor specified usage, that sends and
/// receives 2 absolute bytes ranging from 0 to 0xFF.
///
//////////////////////////////////////////////////////////////////
const char USB_CLASS_SPECIFIC_DESC[] = {
6, 0, 255, // Usage Page = Vendor Defined
9, 1, // Usage = IO device
0xa1, 1, // Collection = Application
0x19, 1, // Usage minimum
0x29, 8, // Usage maximum
0x15, 0x80, // Logical minimum (-128)
0x25, 0x7F, // Logical maximum (127)
0x75, 8, // Report size = 8 (bits)
0x95, 64, // 8 Bytes Old 2 Report count = 16 bits (2 bytes)
0x81, 64, // 8 Old 2 Input (Data, Var, Abs)
0x19, 1, // Usage minimum
0x29, 8, // Usage maximum
0x75, 8, // Report size = 8 (bits)
0x95, 64, // 8 Bytes Old 2 Report count = 16 bits (2 bytes)
0x91, 64, // 8 Old 2 Output (Data, Var, Abs)
0xc0 // End Collection
};
//if a class has an extra descriptor not part of the config descriptor,
// this lookup table defines where to look for it in the const
// USB_CLASS_SPECIFIC_DESC[] array.
//first element is the config number (if your device has more than one config)
//second element is which interface number
//set element to 0xFFFF if this config/interface combo doesn't exist
const int16 USB_CLASS_SPECIFIC_DESC_LOOKUP[USB_NUM_CONFIGURATIONS][1] =
{
//config 1
//interface 0
0
};
//if a class has an extra descriptor not part of the config descriptor,
// this lookup table defines the size of that descriptor.
//first element is the config number (if your device has more than one config)
//second element is which interface number
//set element to 0xFFFF if this config/interface combo doesn't exist
const int16 USB_CLASS_SPECIFIC_DESC_LOOKUP_SIZE[USB_NUM_CONFIGURATIONS][1] =
{
//config 1
//interface 0
32
};
//////////////////////////////////////////////////////////////////
///
/// 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 41 //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 ==1
USB_DESC_CONFIG_TYPE, //constant CONFIGURATION (CONFIGURATION 0x02) ==2
USB_TOTAL_CONFIG_LEN,0, //size of all data returned for this config ==3,4
1, //number of interfaces this device supports ==5
0x01, //identifier for this configuration. (IF we had more than one configurations) ==6
0x00, //index of string descriptor for this configuration ==7
0xC0, //bit 6=1 if self powered, bit 5=1 if supports remote wakeup (we don't), bits 0-4 unused and bit7=1 ==8
0x32, //maximum bus power required (maximum milliamperes/2) (0x32 = 100mA)
//interface descriptor 1
USB_DESC_INTERFACE_LEN, //length of descriptor =10
USB_DESC_INTERFACE_TYPE, //constant INTERFACE (INTERFACE 0x04) =11
0x00, //number defining this interface (IF we had more than one interface) ==12
0x00, //alternate setting ==13
2, //number of endpoins, except 0 (pic167xx has 3, but we dont have to use all). ==14
0x03, //class code, 03 = HID ==15
0x00, //subclass code //boot ==16
0x00, //protocol code ==17
0x00, //index of string descriptor for interface ==18
//class descriptor 1 (HID)
USB_DESC_CLASS_LEN, //length of descriptor ==19
USB_DESC_CLASS_TYPE, //dscriptor type (0x21 == HID) ==20
0x00,0x01, //hid class release number (1.0) (try 1.10) ==21,22
0x00, //localized country code (0 = none) ==23
0x01, //number of hid class descrptors that follow (1) ==24
0x22, //report descriptor type (0x22 == HID) ==25
USB_CLASS_SPECIFIC_DESC_LOOKUP_SIZE[0][0], 0x00, //length of report descriptor ==26,27
//endpoint descriptor
USB_DESC_ENDPOINT_LEN, //length of descriptor ==28
USB_DESC_ENDPOINT_TYPE, //constant ENDPOINT (ENDPOINT 0x05) ==29
0x81, //endpoint number and direction (0x81 = EP1 IN) ==30
0x03, //transfer type supported (0x03 is interrupt) ==31
USB_EP1_TX_SIZE,0x00, //maximum packet size supported ==32,33
250, //polling interval, in ms. (cant be smaller than 10) ==34
//endpoint descriptor
USB_DESC_ENDPOINT_LEN, //length of descriptor ==35
USB_DESC_ENDPOINT_TYPE, //constant ENDPOINT (ENDPOINT 0x05) ==36
0x01, //endpoint number and direction (0x01 = EP1 OUT) ==37
0x03, //transfer type supported (0x03 is interrupt) ==38
USB_EP1_RX_SIZE,0x00, //maximum packet size supported ==39,40
10 //polling interval, in ms. (cant be smaller than 10) ==41
};
//****** 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.
//NOTE: DO TO A LIMITATION OF THE CCS CODE, ALL HID INTERFACES MUST START AT 0 AND BE SEQUENTIAL
// FOR EXAMPLE, IF YOU HAVE 2 HID INTERFACES THEY MUST BE INTERFACE 0 AND INTERFACE 1
#define USB_NUM_HID_INTERFACES 1
//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 1
//define how many interfaces there are per config.
- is the first config, etc.
const char USB_NUM_INTERFACES[USB_NUM_CONFIGURATIONS]={1};
//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][1][1]=
{
//config 1
//interface 0
//class 1
18
};
#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 ==1
0x01, //the constant DEVICE (DEVICE 0x01) ==2
0x10,0x01, //usb version in bcd (pic167xx is 1.1) ==3,4
0x00, //class code ==5
0x00, //subclass code ==6
0x00, //protocol code ==7
USB_MAX_EP0_PACKET_LENGTH, //max packet size for endpoint 0. (SLOW SPEED SPECIFIES
==8
0x61,0x04, //vendor id (0x04D8 is Microchip, or is it 0x0461 ??)
0x20,0x00, //product id ==11,12 //don't use ffff says usb-by-example guy. oops
0x00,0x01, //device release number ==13,14
0x01, //index of string description of manufacturer. therefore we point to string_1 array (see below) ==15
0x02, //index of string descriptor of the product ==16
0x00, //index of string descriptor of serial number ==17
USB_NUM_CONFIGURATIONS //number of possible configurations ==18
};
//////////////////////////////////////////////////////////////////
///
/// 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)
'P',0,
'I',0,
'C',0,
//string 2
12, // longitud del descriptor.
USB_DESC_STRING_TYPE, //descriptor type 0x03 (STRING)
'P',0,
'e',0,
'r',0,
'l',0,
'a',0,
};
#ENDIF
