La mia piccola fusione fredda privata

Sperimentando la fusione fredda

Il contatore Geiger : usb_descriptors.c

Posted Sunday, April 19th, 2015

/********************************************************************
FileName:         usb_descriptors.c
Dependencies:    See INCLUDES section
Processor:        PIC18 or PIC24 USB Microcontrollers
Hardware:        The code is natively intended to be used on the following
hardware platforms: PICDEM™ FS USB Demo Board,
PIC18F87J50 FS USB Plug-In Module, or
Explorer 16 + PIC24 USB PIM.  The firmware may be
modified for use on other USB platforms by editing the
HardwareProfile.h file.
Complier:      Microchip C18 (for PIC18) or C30 (for PIC24)
Company:        Microchip Technology, Inc.

Software License Agreement:

The software supplied herewith by Microchip Technology Incorporated
(the “Company”) for its PIC® Microcontroller is intended and
supplied to you, the Company’s customer, for use solely and
exclusively on Microchip PIC Microcontroller products. The
software is owned by the Company and/or its supplier, and is
protected under applicable copyright laws. All rights are reserved.
Any use in violation of the foregoing restrictions may subject the
user to criminal sanctions under applicable laws, as well as to
civil liability for the breach of the terms and conditions of this
license.

*********************************************************************
-usb_descriptors.c-
——————————————————————-
Filling in the descriptor values in the usb_descriptors.c file:
——————————————————————-

[Device Descriptors]
The device descriptor is defined as a USB_DEVICE_DESCRIPTOR type.
This type is defined in usb_ch9.h  Each entry into this structure
needs to be the correct length for the data type of the entry.

[Configuration Descriptors]
The configuration descriptor was changed in v2.x from a structure
to a BYTE array.  Given that the configuration is now a byte array
each byte of multi-byte fields must be listed individually.  This
means that for fields like the total size of the configuration where
the field is a 16-bit value “64,0,” is the correct entry for a
configuration that is only 64 bytes long and not “64,” which is one
too few bytes.

The configuration attribute must always have the _DEFAULT
definition at the minimum. Additional options can be ORed
to the _DEFAULT attribute. Available options are _SELF and _RWU.
These definitions are defined in the usb_device.h file. The
_SELF tells the USB host that this device is self-powered. The
_RWU tells the USB host that this device supports Remote Wakeup.

[Endpoint Descriptors]
Like the configuration descriptor, the endpoint descriptors were
changed in v2.x of the stack from a structure to a BYTE array.  As
endpoint descriptors also has a field that are multi-byte entities,
please be sure to specify both bytes of the field.  For example, for
the endpoint size an endpoint that is 64 bytes needs to have the size
defined as “64,0,” instead of “64,”

Take the following example:
// Endpoint Descriptor //
0×07,                       //the size of this descriptor //
USB_DESCRIPTOR_ENDPOINT,    //Endpoint Descriptor
_EP02_IN,                   //EndpointAddress
_INT,                       //Attributes
0×08,0×00,                  //size (note: 2 bytes)
0×02,                       //Interval

The first two parameters are self-explanatory. They specify the
length of this endpoint descriptor (7) and the descriptor type.
The next parameter identifies the endpoint, the definitions are
defined in usb_device.h and has the following naming
convention:
_EP<##>_<dir>
where ## is the endpoint number and dir is the direction of
transfer. The dir has the value of either ‘OUT’ or ‘IN’.
The next parameter identifies the type of the endpoint. Available
options are _BULK, _INT, _ISO, and _CTRL. The _CTRL is not
typically used because the default control transfer endpoint is
not defined in the USB descriptors. When _ISO option is used,
addition options can be ORed to _ISO. Example:
_ISO|_AD|_FE
This describes the endpoint as an isochronous pipe with adaptive
and feedback attributes. See usb_device.h and the USB
specification for details. The next parameter defines the size of
the endpoint. The last parameter in the polling interval.

——————————————————————-
Adding a USB String
——————————————————————-
A string descriptor array should have the following format:

rom struct{byte bLength;byte bDscType;word string[size];}sdxxx={
sizeof(sdxxx),DSC_STR,<text>};

The above structure provides a means for the C compiler to
calculate the length of string descriptor sdxxx, where xxx is the
index number. The first two bytes of the descriptor are descriptor
length and type. The rest <text> are string texts which must be
in the unicode format. The unicode format is achieved by declaring
each character as a word type. The whole text string is declared
as a word array with the number of characters equals to <size>.
<size> has to be manually counted and entered into the array
declaration. Let’s study this through an example:
if the string is “USB” , then the string descriptor should be:
(Using index 02)
rom struct{byte bLength;byte bDscType;word string[3];}sd002={
sizeof(sd002),DSC_STR,’U',’S',’B'};

A USB project may have multiple strings and the firmware supports
the management of multiple strings through a look-up table.
The look-up table is defined as:
rom const unsigned char *rom USB_SD_Ptr[]={&sd000,&sd001,&sd002};

The above declaration has 3 strings, sd000, sd001, and sd002.
Strings can be removed or added. sd000 is a specialized string
descriptor. It defines the language code, usually this is
US English (0×0409). The index of the string must match the index
position of the USB_SD_Ptr array, &sd000 must be in position
USB_SD_Ptr[0], &sd001 must be in position USB_SD_Ptr[1] and so on.
The look-up table USB_SD_Ptr is used by the get string handler
function.

——————————————————————-

The look-up table scheme also applies to the configuration
descriptor. A USB device may have multiple configuration
descriptors, i.e. CFG01, CFG02, etc. To add a configuration
descriptor, user must implement a structure similar to CFG01.
The next step is to add the configuration descriptor name, i.e.
cfg01, cfg02,.., to the look-up table USB_CD_Ptr. USB_CD_Ptr[0]
is a dummy place holder since configuration 0 is the un-configured
state according to the definition in the USB specification.

********************************************************************/

/*********************************************************************
* Descriptor specific type definitions are defined in:
* usb_device.h
*
* Configuration options are defined in:
* usb_config.h
********************************************************************/
#ifndef __USB_DESCRIPTORS_C
#define __USB_DESCRIPTORS_C

/** INCLUDES *******************************************************/
#include “usb.h”
#include “usb_function_msd.h”
#include “usb_function_hid.h”
#include “contatoregeiger.h”

/** CONSTANTS ******************************************************/

/* Device Descriptor */
ROM USB_DEVICE_DESCRIPTOR device_dsc={
0×12,    // Size of this descriptor in bytes
USB_DESCRIPTOR_DEVICE,                // DEVICE descriptor type
0×0200,                 // USB Spec Release Number in BCD format
0×00,                   // Class Code
0×00,                   // Subclass code
0×00,                   // Protocol code
USB_EP0_BUFF_SIZE,          // Max packet size for EP0, see usb_config.h
0x115f,                 // Vendor ID: Cyberdyne/ADPM
0×0261,                 // Product ID: Geiger (mass storage + HID)
0×0001,                 // Device release number in BCD format
0×01,                   // Manufacturer string index
0×02,                   // Product string index
0×03,                   // Device serial number string index
0×01                    // Number of possible configurations
};

/* Configuration 1 Descriptor */
ROM BYTE configDescriptor1[]={
/* Configuration Descriptor */
9,    // Size of this descriptor in bytes
USB_DESCRIPTOR_CONFIGURATION,                // CONFIGURATION descriptor type
0×40,0×00,          // Total length of data for this cfg
2,                      // Number of interfaces in this cfg
1,                      // Index value of this configuration
0,                      // Configuration string index
_DEFAULT | _SELF,               // Attributes, see usb_device.h
50,                     // Max power consumption (2X mA)

/* Interface Descriptor */
9,   // Size of this descriptor in bytes
USB_DESCRIPTOR_INTERFACE,               // INTERFACE descriptor type
MSD_INTF_ID,                      // Interface Number
0,                      // Alternate Setting Number
2,                      // Number of endpoints in this intf
MSD_INTF,               // Class code
MSD_INTF_SUBCLASS,      // Subclass code
MSD_PROTOCOL,             // Protocol code
0,                      // Interface string index

/* Endpoint Descriptor */
7,
USB_DESCRIPTOR_ENDPOINT,
_EP01_IN,_BULK,
MSD_IN_EP_SIZE,0×00,
0×01,

7,
USB_DESCRIPTOR_ENDPOINT,
_EP01_OUT,
_BULK,
MSD_OUT_EP_SIZE,0×00,
0×01,

/* Interface Descriptor */
0×09,//sizeof(USB_INTF_DSC),   // Size of this descriptor in bytes
USB_DESCRIPTOR_INTERFACE,               // INTERFACE descriptor type
HID_INTF_ID,                      // Interface Number
0,                      // Alternate Setting Number
2,                      // Number of endpoints in this intf
HID_INTF,               // Class code
0,     // Subclass code
0,     // Protocol code
0,                      // Interface string index

/* HID Class-Specific Descriptor */
0×09,//sizeof(USB_HID_DSC)+3,    // Size of this descriptor in bytes RRoj hack
DSC_HID,                // HID descriptor type
0×11,0×01,                 // HID Spec Release Number in BCD format (1.11)
0×00,                   // Country Code (0×00 for Not supported)
HID_NUM_OF_DSC,         // Number of class descriptors, see usbcfg.h
DSC_RPT,                // Report descriptor type
HID_RPT01_SIZE,0×00,//sizeof(hid_rpt01),      // Size of the report descriptor

/* Endpoint Descriptor */
0×07,/*sizeof(USB_EP_DSC)*/
USB_DESCRIPTOR_ENDPOINT,    //Endpoint Descriptor
HID_EP | _EP_IN,                   //EndpointAddress
_INTERRUPT,                       //Attributes
0×40,0×00,                  //size
0×01,                        //Interval

/* Endpoint Descriptor */
0×07,/*sizeof(USB_EP_DSC)*/
USB_DESCRIPTOR_ENDPOINT,    //Endpoint Descriptor
HID_EP | _EP_OUT,                   //EndpointAddress
_INTERRUPT,                       //Attributes
0×40,0×00,                  //size
0×01                        //Interval
};

//Class specific descriptor – HID
ROM struct{BYTE report[HID_RPT01_SIZE];} hid_rpt01={
{
0×06, 0×00, 0xff,              // USAGE_PAGE (Vendor Defined Page 1)
0×09, 0×01,                    // USAGE (Vendor Usage 1)
0xa1, 0×01,                    // COLLECTION (Application)
// ——– common global items ———
0×15, 0×00,                    //   LOGICAL_MINIMUM (0)
0×26, 0xff, 0×00,              //   LOGICAL_MAXIMUM (255)
0×75, 0×08,                    //   REPORT_SIZE (8)
// ——– input report ———
0×85, 1, /*      Report ID (1)                                                */
0×95, HID_INT_IN_EP_SIZE-1,                    //   REPORT_COUNT (64)
0×19, 0×01,                    //   USAGE_MINIMUM (Vendor Usage 1)
0×29, HID_INT_IN_EP_SIZE,                    //   USAGE_MAXIMUM (Vendor Usage 64)
0×81, 0×02,                    //   INPUT (Data,Var,Abs)
// ——– output report ———
0×85, 2, /*      Report ID (2)                                                */
0×95, HID_INT_OUT_EP_SIZE-1,                    //   REPORT_COUNT (64)
0×19, 0×01,                    //   USAGE_MINIMUM (Vendor Usage 1)
0×29, HID_INT_OUT_EP_SIZE,                    //   USAGE_MAXIMUM (Vendor Usage 64)
0×91, 0×02,                    //   OUTPUT (Data,Var,Abs)
// ——– feature report ———
0×85, 3, /*      Report ID (3)                                                */
0×95, HID_FEATURE_REPORT_BYTES-1,                    //   REPORT_COUNT ()
0×09, 0×01,                    //   USAGE (Vendor Usage 1)
0xb1, 0×02,                    //   FEATURE (Data,Var,Abs)

0xc0                           // END_COLLECTION
}                   // End Collection
};

//Language code(s) supported string descriptor
ROM struct{BYTE bLength;BYTE bDscType;WORD string[1];} sd000={
sizeof(sd000),
USB_DESCRIPTOR_STRING,
{0×0409}    //0×0409 = Language ID code for US English
};
//Manufacturer string descriptor
ROM struct{BYTE bLength;BYTE bDscType;WORD string[10];} sd001={
sizeof(sd001),USB_DESCRIPTOR_STRING,
{‘C’,'y’,'b’,'e’,'r’,'d’,'y’,'n’,'e’
}};

//Product string descriptor
ROM struct{BYTE bLength;BYTE bDscType;WORD string[35];} sd002={
sizeof(sd002),USB_DESCRIPTOR_STRING,
//    {‘M’,'i’,'c’,'r’,'o’,'c’,'h’,'i’,'p’,’ ‘,’M',’a',’s',’s',’ ‘,’S',’t',’o',’r',’a',’g',’e',’ ‘,’D',’r',’i',’v',’e’
{‘C’,'y’,'b’,'e’,'r’,'d’,'y’,'n’,'e’,’ ‘,’G',’e',’i',’g',’e',’r',’+',’M',’a',’s',’s',’ ‘,’S',’t',’o',’r',’a',’g',’e',’ ‘,’D',’r',’i',’v',’e’
}};

//Serial number string descriptor.  Note: This should be unique for each unit
//built on the assembly line.  Plugging in two units simultaneously with the
//same serial number into a single machine can cause problems.  Additionally, not
//all hosts support all character values in the serial number string.  The MSD
//Bulk Only Transport (BOT) specs v1.0 restrict the serial number to consist only
//of ASCII characters “0″ through “9″ and capital letters “A” through “F”.
ROM struct{BYTE bLength;BYTE bDscType;WORD string[12];} sd003={
sizeof(sd003),USB_DESCRIPTOR_STRING,
{’1′,’2′,’3′,’4′,’5′,’6′,’7′,’8′,’9′,’0′,’8′,’8′}
};

ROM struct { BYTE bLength; BYTE bDscType; WORD string[5]; } sd004 = {
sizeof(sd004),USB_DESCRIPTOR_STRING,
{‘V’,VERNUMH+’0′,’.',VERNUML/10+’0′,(VERNUML % 10)+’0′}};

ROM struct { BYTE bLength; BYTE bDscType; WORD string[12]; } sd005 = {
sizeof(sd005),USB_DESCRIPTOR_STRING,
{‘ ‘,’+',’ ‘,’+',’ ‘,’ ‘,’ ‘,’ ‘,’ ‘,’ ‘,’ ‘,’ ‘}};

//Array of configuration descriptors
ROM BYTE *ROM USB_CD_Ptr[]={
(ROM BYTE *ROM)&configDescriptor1
};

//Array of string descriptors
ROM BYTE *ROM USB_SD_Ptr[]={
(ROM BYTE *ROM)&sd000,
(ROM BYTE *ROM)&sd001,
(ROM BYTE *ROM)&sd002,
(ROM BYTE *ROM)&sd003,
(ROM BYTE *ROM)&sd004,
(ROM BYTE *ROM)&sd005
};

/** EOF usb_descriptors.c ***************************************************/

#endif