// USBFunctions.c
// includes ///////////////////////////////////////////////////////////////////////////////////////
#include<p18f4550.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<limits.h>
#include"USBFunctions.h"
// global variables ///////////////////////////////////////////////////////////////////////////////
#pragma udata USB_BDT = 0x400 // see linker script, usb4: 0x400 - 0x4FF (256 byte)
volatile BDT_ENTRY g_buffDescTable[4]; // 4 bytes each, 16 bytes total
volatile CTRL_TRF_SETUP g_ctrlTrfSetupPkt; // 8 bytes
volatile BYTE g_ctrlTrfData[USB_EP0_BUFF_SIZE]; // 1 byte each, 8 bytes total
#pragma udata // end of #pragma udata USB_BDT = 0x400 32 bytes total
#pragma udata USB_VARS
BYTE g_fromHostToDeviceBuffer[65];
BYTE g_fromDeviceToHostBuffer[65];
#pragma udata // end of #pragma udata USB_VARS
OUT_PIPE g_outPipe;
IN_PIPE g_inPipe;
BYTE g_USBDeviceState = DETACHED_STATE;
BYTE g_USBDeviceState;
BYTE g_controlTransferState;
BYTE g_USBActiveConfiguration;
BYTE g_shortPacketStatus;
#pragma romdata // USB device descriptors
// device descriptor
rom USB_DEVICE_DESCRIPTOR g_userDeviceDescriptor = { 0x12,
USB_DESCRIPTOR_DEVICE,
0x0200,
0x00,
0x00,
0x00,
USB_EP0_BUFF_SIZE,
0x04D8, // Vendor ID (VID)
0x003F, // Product ID (PID)
0x0002,
0x01,
0x02,
0x00,
0x01 };
// config 1 descriptor
rom BYTE g_configDescriptor1[] = { 0x09, // config descriptor
USB_DESCRIPTOR_CONFIGURATION,
0x29,
0x00,
1,
1,
0,
_DEFAULT | _SELF,
50,
0x09, // interface descriptor
USB_DESCRIPTOR_INTERFACE,
0,
0,
2,
HID_INTF,
0,
0,
0,
0x09, // HID descriptor
HID_DESCRIPTOR,
0x11,
0x01,
0x00,
HID_NUM_OF_DSC,
REPORT_DESCRIPTOR,
HID_RPT01_SIZE, 0x00,
0x07, // endpoint descriptor
USB_DESCRIPTOR_ENDPOINT,
1 | _EP_IN,
_INT,
0x40,
0x00,
0x01,
0x07, // endpoint descriptor
USB_DESCRIPTOR_ENDPOINT,
1 | _EP_OUT,
_INT,
0x40,
0x00,
0x01 };
// language code string descriptor
rom struct{BYTE bLength; BYTE bDscType; WORD string[1];} g_stringDescript000 = { sizeof(g_stringDescript000), USB_DESCRIPTOR_STRING, { 0x0409 } };
// mfg. string descriptor
rom struct{BYTE bLength; BYTE bDscType; WORD string[25];} g_stringDescript001 = { sizeof(g_stringDescript001),
USB_DESCRIPTOR_STRING,
{'M','i','c','r','o','c','h','i','p',' ','T','e','c','h','n','o','l','o','g','y',' ','I','n','c','.'} };
// product string descriptor
rom struct{BYTE bLength; BYTE bDscType; WORD string[22];} g_stringDescript002 = { sizeof(g_stringDescript002),
USB_DESCRIPTOR_STRING,
{'S','i','m','p','l','e',' ','H','I','D',' ','D','e','v','i','c','e',' ','D','e','m','o'} };
rom struct{BYTE report[HID_RPT01_SIZE];} g_HIDReport01 = { { 0x06, 0x00, 0xFF,
0x09, 0x01,
0xA1, 0x01,
0x19, 0x01,
0x29, 0x40,
0x15, 0x00,
0x26, 0xFF, 0x00,
0x75, 0x08,
0x95, 0x40,
0x81, 0x02,
0x19, 0x01,
0x29, 0x40,
0x91, 0x02,
0xC0 } };
// array of config descriptors
rom BYTE *rom g_userConfigDescriptorPtr[] = { (rom BYTE *rom)&g_configDescriptor1 };
// array of string descriptors
rom BYTE *rom g_USBStringDescPtr[] = { (rom BYTE *rom)&g_stringDescript000,
(rom BYTE *rom)&g_stringDescript001,
(rom BYTE *rom)&g_stringDescript002 };
#pragma udata // end of #pragma romdata for descriptor global variables
#pragma code
///////////////////////////////////////////////////////////////////////////////////////////////////
void USBInit(void) {
BYTE i;
UEIR = 0x00; // clear USB error interrupt status register
UIR = 0x00; // clear USB interrupt status register
// UEIE -> USB error interrupt enable register
UEIEbits.BTSEE = 1; // bit stuff error interrupt enabled
UEIEbits.BTOEE = 1; // bus turnaround time-out error interrupt enabled
UEIEbits.DFN8EE = 1; // data field size error interrupt enabled
UEIEbits.CRC16EE = 1; // CRC16 failure interrupt enabled
UEIEbits.CRC5EE = 1; // CRC5 host error interrupt enabled
UEIEbits.PIDEE = 1; // PID check failure interrupt enabled
// UIE -> USB interrupt enable register
UIEbits.SOFIE = 1; // start of frame token interrupt enabled
UIEbits.STALLIE = 1; // STALL interrupt enabled
UIEbits.IDLEIE = 1; // idle detect interrupt enabled
UIEbits.TRNIE = 1; // transaction interrupt enabled
UIEbits.ACTVIE = 0; // bus activity detect interrupt disabled
UIEbits.UERRIE = 1; // USB error interrupt enabled
UIEbits.URSTIE = 1; // USB reset interrupt enabled
UCONbits.PPBRST = 1; // reset ping-pong buffer pointers to even buffer descriptor banks
UCONbits.PPBRST = 0; // ping-pong buffer pointers not being reset
UADDR = 0x00; // set USB address register
for(i=0; i<(sizeof(g_buffDescTable) / sizeof(BDT_ENTRY)); i++) { // clear all buffer descriptor table entries
g_buffDescTable[i].STAT.STATVal = 0x00;
g_buffDescTable[i].CNT = 0x00;
g_buffDescTable[i].ADR = 0x0000;
}
// USB endpoint 0 configuration
UEP0bits.EPHSHK = 1; // endpoint 0 handshake enabled
UEP0bits.EPCONDIS = 0; // enable endpoint 0 for control (SETUP) transfers, IN & OUT transfers also allowed
UEP0bits.EPOUTEN = 1; // endpoint 0 output enabled
UEP0bits.EPINEN = 1; // endpoint 0 input enabled
UEP0bits.EPSTALL = 0; // endpoint 0 has not issued any STALL packets
// flush any pending transactions
while(UIRbits.TRNIF == 1) { // while processing of pending transaction is complete . . .
UIRbits.TRNIF = 0; // set processing of pending transaction to not complete
}
g_inPipe.busy = 0; // clear all internal pipe information
g_outPipe.busy = 0;
g_outPipe.wCount = 0;
UCONbits.PKTDIS = 0; // SIE token & packet processing enabled
g_USBActiveConfiguration = 0; // clear active configuration
g_USBDeviceState = DETACHED_STATE; // init state to detached
g_fromHostToDeviceBuffer[1] = 0x00;
g_fromHostToDeviceBuffer[2] = 0x00;
g_fromHostToDeviceBuffer[3] = 0x32;
g_fromHostToDeviceBuffer[4] = 0x8E;
g_fromHostToDeviceBuffer[5] = 0x6E;
g_fromHostToDeviceBuffer[6] = 0x32;
g_fromDeviceToHostBuffer[1] = 0x00;
g_fromDeviceToHostBuffer[2] = 0x00;
g_fromDeviceToHostBuffer[3] = 0x00;
g_fromDeviceToHostBuffer[4] = 0x00;
g_fromDeviceToHostBuffer[5] = 0x00;
g_fromDeviceToHostBuffer[6] = 0x00;
g_fromDeviceToHostBuffer[7] = 0x00;
for(i=7;i<65;i++) { // init buffer arrays to zero
g_fromHostToDeviceBuffer[i] = 0x00;
g_fromDeviceToHostBuffer[i] = 0x00;
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void USBTasks(void) {
BYTE i;
if(g_USBDeviceState == DETACHED_STATE) { // if we are in detached state
UCON = 0x00; // disable & detach from bus
UIE = 0x00; // disable all UIE interrupts
while(UCONbits.USBEN == 0) {
UCONbits.USBEN = 1; // enable & attach to bus
}
g_USBDeviceState = ATTACHED_STATE; // update state variable
// USB config register
UCFGbits.UTEYE = 0; // eye pattern test disabled
UCFGbits.UOEMON = 0; // USB output enable monitor enable bit
UCFGbits.UPUEN = 1; // on chip pull-up resistors enabled
UCFGbits.UTRDIS = 0; // on chip transceiver active
UCFGbits.FSEN = 1; // full speed clock (48 MHz)
UCFGbits.PPB1 = 0; // no ping pong
UCFGbits.PPB0 = 0; // no ping pong
}
if(g_USBDeviceState == ATTACHED_STATE) {
/* After enabling the USB module, it takes some time for the voltage on the D+ or D- lines to rist high enough
to get out of the single-ended zero condition. The USB reset interrupt should not be unmasked until the
SE0 condition is cleared, this helps prevent the firmware from misinterpreting a single-ended zero condition
as a USB bus reset from the USB host */
if(UCONbits.SE0 == 0) { // if not a single-ended zero condition . . .
UIR = 0x00; // clear interrupt register
UIE = 0x00; // disable all UIE interrupts
UIEbits.URSTIE = 1; // USB reset interrupt enabled
UIEbits.IDLEIE = 1; // idle detect interrupt enabled
g_USBDeviceState = POWERED_STATE; // update state
}
}
if(UIRbits.ACTVIF && // if D+ / D- activity detected
UIEbits.ACTVIE) { // and bus activity detect interrupt enabled . . .
USBWakeFromSuspend();
}
if(UCONbits.SUSPND == 1) {
return;
}
if(UIRbits.URSTIF && // if valid USB reset occurred
UIEbits.URSTIE) { // USB reset interrupt enabled
USBInit(); // call init again
g_USBDeviceState = DEFAULT_STATE; // set state variable
g_buffDescTable[0].ADR = (BYTE*)&g_ctrlTrfSetupPkt;
g_buffDescTable[0].CNT = USB_EP0_BUFF_SIZE;
g_buffDescTable[0].STAT.DTS = 0; // data toggle synch bit
g_buffDescTable[0].STAT.KEN = 0; // keep enable bit
g_buffDescTable[0].STAT.INCDIS = 0; // address increment disable bit
g_buffDescTable[0].STAT.DTSEN = 1; // data toggle synch enable bit
g_buffDescTable[0].STAT.BSTALL = 1; // buffer stall enable bit
g_buffDescTable[0].STAT.BC9 = 0; // byte count 9 bit
g_buffDescTable[0].STAT.BC8 = 0; // byte count 8 bit
g_buffDescTable[0].STAT.UOWN = 1; // UOWN bit (SIE owns buffer)
}
if(UIRbits.IDLEIF && // if idle detected
UIEbits.IDLEIE) { // and idle detect interrupt enabled . . .
USBSuspend();
}
if(UIRbits.SOFIF && // if start of frame token received by SIE
UIEbits.SOFIE) { // and start of frame token interrupt enabled . . .
UIRbits.SOFIF = 0; // clear start of frame token bit
}
if(UIRbits.STALLIF && // if stall handshake sent by SIE
UIEbits.STALLIE) { // and stall interrupt enabled . . .
USBStallHandler();
}
if(UIRbits.UERRIF && // if unmasked error has occurred
UIEbits.UERRIE) { // and error interrupt enabled . . .
UEIR = 0x00; // clear USB error interrupt register
}
if(g_USBDeviceState < DEFAULT_STATE) return; // bail if we have not at least reached default state
if(UIEbits.TRNIE) { // if transaction interrupts enabled
for(i=0;i<4;i++) { // for each entry in the USTAT FIFO . . .
if(UIRbits.TRNIF) { // if processing of pending transaction is complete . . .
if(USTATbits.ENDP3 == 0 &&
USTATbits.ENDP2 == 0 &&
USTATbits.ENDP1 == 0 &&
USTATbits.ENDP0 == 0) { // if last transfer was EP0 . . .
USBEP0ControlTransfer(); // this leads to g_USBDeviceState = CONFIGURED_STATE
}
UIRbits.TRNIF = 0; // clear transaction complete interrupt bit, causes USTAT FIFO to advance
} else { // else jump out of for loop
break; // this kicks out of the for loop
}
}
// break keyword takes us to here
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void USBWakeFromSuspend(void) {
UCONbits.SUSPND = 0; // clear suspend bit (wake from suspend)
UIEbits.ACTVIE = 0; // disable bus activity detect interrupt
while(UIRbits.ACTVIF) { // while activity on D+/D- lines was detected . . .
UIRbits.ACTVIF = 0; // clear bus activity detect interrupt flag bit
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void USBSuspend(void) {
UIEbits.ACTVIE = 1; // set bus activity detect interrupt enable bit
UIRbits.IDLEIF = 0; // clear idle detect interrupt bit
UCONbits.SUSPND = 1; // set USB suspend bit (enter suspend mode)
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void USBStallHandler(void) {
if(UEP0bits.EPSTALL == 1) { // if endpoint 0 has issued one or more stall packets . . .
if((g_buffDescTable[0].STAT.UOWN == 1) && (g_buffDescTable[1].STAT.UOWN == 1)) {
g_buffDescTable[0].STAT.DTS = 0; // data toggle synch bit
g_buffDescTable[0].STAT.KEN = 0; // keep enable bit
g_buffDescTable[0].STAT.INCDIS = 0; // address increment disable bit
g_buffDescTable[0].STAT.DTSEN = 1; // data toggle synch enable bit
g_buffDescTable[0].STAT.BSTALL = 1; // buffer stall enable bit
g_buffDescTable[0].STAT.BC9 = 0; // byte count 9 bit
g_buffDescTable[0].STAT.BC8 = 0; // byte count 8 bit
g_buffDescTable[0].STAT.UOWN = 1; // UOWN bit (SIE owns buffer)
}
UEP0bits.EPSTALL = 0; // clear endpoint 0 stall indicator bit
}
UIRbits.STALLIF = 0; // clear stall handshake interrupt bit
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void USBEP0ControlTransfer(void) {
if(USTATbits.DIR == 0) { // if last trans was EP0 and OUT or SETUP
if(g_buffDescTable[0].STAT.PID == SETUP_TOKEN) {
USBSetupControlTransfer(); // this leads to g_USBDeviceState = CONFIGURED_STATE
} else {
USBOutControlTransfer();
}
} else if(USTATbits.DIR == 1) { // if last trans was EP0 and IN
USBInControlTransfer();
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void USBSetupControlTransfer(void) {
g_buffDescTable[1].STAT.STATVal = 0x00;
g_shortPacketStatus = SHORT_PKT_NOT_USED;
g_controlTransferState = CTRL_TRF_WAIT_SETUP;
g_inPipe.wCount = 0;
g_inPipe.busy = 0;
USBCheckStandardRequest(); // this leads to g_USBDeviceState = CONFIGURED_STATE
USBCheckHIDRequest();
USBFinishControlTransferStuff();
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void USBCheckStandardRequest(void) {
if(g_ctrlTrfSetupPkt.RequestType != STANDARD) return;
if(g_ctrlTrfSetupPkt.bRequest == SET_ADDRESS) {
g_inPipe.busy = 1;
g_USBDeviceState = ADR_PENDING_STATE;
} else if(g_ctrlTrfSetupPkt.bRequest == GET_DESCRIPTOR) {
if(g_ctrlTrfSetupPkt.bmRequestType == 0x80) {
g_inPipe.busy = 1;
if(g_ctrlTrfSetupPkt.bDescriptorType == USB_DESCRIPTOR_DEVICE) {
g_inPipe.bRom = (rom BYTE*)&g_userDeviceDescriptor;
g_inPipe.wCount = sizeof(g_userDeviceDescriptor);
} else if(g_ctrlTrfSetupPkt.bDescriptorType == USB_DESCRIPTOR_CONFIGURATION) {
g_inPipe.bRom = *(g_userConfigDescriptorPtr + g_ctrlTrfSetupPkt.bDscIndex);
g_inPipe.wRom = (rom WORD*)g_inPipe.bRom;
g_inPipe.wCount = *(g_inPipe.wRom + 1);
} else if(g_ctrlTrfSetupPkt.bDescriptorType == USB_DESCRIPTOR_STRING) {
g_inPipe.bRom = *(g_USBStringDescPtr + g_ctrlTrfSetupPkt.bDscIndex);
g_inPipe.wCount = *g_inPipe.bRom;
} else {
g_inPipe.busy = 0;
}
}
} else if(g_ctrlTrfSetupPkt.bRequest == SET_CONFIGURATION) {
g_inPipe.busy = 1;
g_USBActiveConfiguration = g_ctrlTrfSetupPkt.bConfigurationValue;
if(g_ctrlTrfSetupPkt.bConfigurationValue == 0) {
g_USBDeviceState = ADDRESS_STATE;
} else {
g_USBDeviceState = CONFIGURED_STATE; // this is the only line in the program that changes g_USBDeviceState to CONFIGURED_STATE
// enable & configure endpoint 1
UEP1bits.EPHSHK = 1; // endpoint 1 handshake enabled
UEP1bits.EPCONDIS = 1; // disable endpoint 1 from performing control (i.e. setup) transfers
UEP1bits.EPOUTEN = 1; // endpoint 1 output enabled
UEP1bits.EPINEN = 1; // endpoint 1 input enabled
UEP1bits.EPSTALL = 0; // clear endpoint 1 stall indicator bit
g_buffDescTable[2].STAT.UOWN = 0;
g_buffDescTable[2].STAT.DTS = 1;
g_buffDescTable[3].STAT.UOWN = 0;
g_buffDescTable[3].STAT.DTS = 1;
transferFromHostToDeviceViaEP1((BYTE*)&g_fromHostToDeviceBuffer[1], 64);
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void USBCheckHIDRequest(void) {
if(g_ctrlTrfSetupPkt.Recipient != RECIPIENT_INTERFACE) return;
if(g_ctrlTrfSetupPkt.bRequest == GET_DESCRIPTOR) {
if(g_ctrlTrfSetupPkt.bDescriptorType == HID_DESCRIPTOR) {
if(g_USBActiveConfiguration == 1) {
g_inPipe.bRom = (rom BYTE*)&g_configDescriptor1 + 18;
g_inPipe.wCount = sizeof(USB_HID_DSC) + 3;
g_inPipe.busy = 1;
}
} else if(g_ctrlTrfSetupPkt.bDescriptorType == REPORT_DESCRIPTOR) {
if(g_USBActiveConfiguration == 1) {
g_inPipe.bRom = (rom BYTE*)&g_HIDReport01;
g_inPipe.wCount = sizeof(g_HIDReport01);
g_inPipe.busy = 1;
}
} else if(g_ctrlTrfSetupPkt.bDescriptorType == PHY_DESCRIPTOR) {
g_inPipe.busy = 1;
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void USBFinishControlTransferStuff(void) {
UCONbits.PKTDIS = 0;
if(g_inPipe.busy == 0) {
if(g_outPipe.busy == 1) {
//
} else {
g_buffDescTable[0].CNT = USB_EP0_BUFF_SIZE;
g_buffDescTable[0].ADR = (BYTE*)&g_ctrlTrfSetupPkt;
g_buffDescTable[0].STAT.DTS = 0; // clear data toggle synch bit
g_buffDescTable[0].STAT.KEN = 0; // clear keep enable bit
g_buffDescTable[0].STAT.INCDIS = 0; // clear address increment disable bit
g_buffDescTable[0].STAT.DTSEN = 1; // set data toggle synch enable bit
g_buffDescTable[0].STAT.BSTALL = 1; // set buffer stall enable bit
g_buffDescTable[0].STAT.BC9 = 0; // clear byte count 9 bit
g_buffDescTable[0].STAT.BC8 = 0; // clear byte count 8 bit
g_buffDescTable[0].STAT.UOWN = 1; // set UOWN bit (SIE owns buffer)
g_buffDescTable[1].STAT.DTS = 0; // clear data toggle synch bit
g_buffDescTable[1].STAT.KEN = 0; // clear keep enable bit
g_buffDescTable[1].STAT.INCDIS = 0; // clear address increment disable bit
g_buffDescTable[1].STAT.DTSEN = 0; // clear data toggle synch enable bit
g_buffDescTable[1].STAT.BSTALL = 1; // set buffer stall enable bit
g_buffDescTable[1].STAT.BC9 = 0; // clear byte count 9 bit
g_buffDescTable[1].STAT.BC8 = 0; // clear byte count 8 bit
g_buffDescTable[1].STAT.UOWN = 1; // set UOWN bit (SIE owns buffer)
}
} else {
if(g_outPipe.busy == 0) {
if(g_ctrlTrfSetupPkt.DataDir == DEV_TO_HOST) {
if(g_ctrlTrfSetupPkt.wLength < g_inPipe.wCount) {
g_inPipe.wCount = g_ctrlTrfSetupPkt.wLength;
}
USBControlTransferTransmit();
g_controlTransferState = CTRL_TRF_TX;
g_buffDescTable[0].CNT = USB_EP0_BUFF_SIZE;
g_buffDescTable[0].ADR = (BYTE*)&g_ctrlTrfSetupPkt;
g_buffDescTable[0].STAT.DTS = 0; // data toggle synch bit
g_buffDescTable[0].STAT.KEN = 0; // keep enable bit
g_buffDescTable[0].STAT.INCDIS = 0; // address increment disable bit
g_buffDescTable[0].STAT.DTSEN = 0; // data toggle synch enable bit
g_buffDescTable[0].STAT.BSTALL = 0; // buffer stall enable bit
g_buffDescTable[0].STAT.BC9 = 0; // byte count 9 bit
g_buffDescTable[0].STAT.BC8 = 0; // byte count 8 bit
g_buffDescTable[0].STAT.UOWN = 1; // UOWN bit (SIE owns buffer)
g_buffDescTable[1].ADR = (BYTE*)&g_ctrlTrfData;
g_buffDescTable[1].STAT.DTS = 1; // data toggle synch bit
g_buffDescTable[1].STAT.KEN = 0; // keep enable bit
g_buffDescTable[1].STAT.INCDIS = 0; // address increment disable bit
g_buffDescTable[1].STAT.DTSEN = 1; // data toggle synch enable bit
g_buffDescTable[1].STAT.BSTALL = 0; // buffer stall enable bit
g_buffDescTable[1].STAT.BC9 = 0; // byte count 9 bit
g_buffDescTable[1].STAT.BC8 = 0; // byte count 8 bit
g_buffDescTable[1].STAT.UOWN = 1; // UOWN bit (SIE owns buffer)
} else {
g_controlTransferState = CTRL_TRF_RX;
g_buffDescTable[1].CNT = 0;
g_buffDescTable[1].STAT.DTS = 1; // data toggle synch bit
g_buffDescTable[1].STAT.KEN = 0; // keep enable bit
g_buffDescTable[1].STAT.INCDIS = 0; // address increment disable bit
g_buffDescTable[1].STAT.DTSEN = 1; // data toggle synch enable bit
g_buffDescTable[1].STAT.BSTALL = 0; // buffer stall enable bit
g_buffDescTable[1].STAT.BC9 = 0; // byte count 9 bit
g_buffDescTable[1].STAT.BC8 = 0; // byte count 8 bit
g_buffDescTable[1].STAT.UOWN = 1; // UOWN bit (SIE owns buffer)
g_buffDescTable[0].CNT = USB_EP0_BUFF_SIZE;
g_buffDescTable[0].ADR = (BYTE*)&g_ctrlTrfData;
g_buffDescTable[0].STAT.DTS = 1; // data toggle synch bit
g_buffDescTable[0].STAT.KEN = 0; // keep enable bit
g_buffDescTable[0].STAT.INCDIS = 0; // address increment disable bit
g_buffDescTable[0].STAT.DTSEN = 1; // data toggle synch enable bit
g_buffDescTable[0].STAT.BSTALL = 0; // buffer stall enable bit
g_buffDescTable[0].STAT.BC9 = 0; // byte count 9 bit
g_buffDescTable[0].STAT.BC8 = 0; // byte count 8 bit
g_buffDescTable[0].STAT.UOWN = 1; // UOWN bit (SIE owns buffer)
}
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void USBOutControlTransfer(void) {
if(g_controlTransferState == CTRL_TRF_RX) {
USBControlTransferReceive();
} else {
USBPrepareForNextSetupTransfer();
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void USBInControlTransfer(void) {
BYTE lastDTS;
lastDTS = g_buffDescTable[1].STAT.DTS;
if(g_USBDeviceState == ADR_PENDING_STATE) {
UADDR = g_ctrlTrfSetupPkt.bDevADR;
if(UADDR > 0) {
g_USBDeviceState = ADDRESS_STATE;
} else {
g_USBDeviceState = DEFAULT_STATE;
}
}
if(g_controlTransferState == CTRL_TRF_TX) {
g_buffDescTable[1].ADR = (BYTE*)g_ctrlTrfData;
USBControlTransferTransmit();
if(g_shortPacketStatus == SHORT_PKT_SENT) {
g_buffDescTable[1].STAT.DTS = 0; // data toggle synch bit
g_buffDescTable[1].STAT.KEN = 0; // keep enable bit
g_buffDescTable[1].STAT.INCDIS = 0; // address increment disable bit
g_buffDescTable[1].STAT.DTSEN = 0; // data toggle synch enable bit
g_buffDescTable[1].STAT.BSTALL = 1; // buffer stall enable bit
g_buffDescTable[1].STAT.BC9 = 0; // byte count 9 bit
g_buffDescTable[1].STAT.BC8 = 0; // byte count 8 bit
g_buffDescTable[1].STAT.UOWN = 1; // UOWN bit (SIE owns buffer)
} else {
if(lastDTS == 0) {
g_buffDescTable[1].STAT.DTS = 1; // data toggle synch bit
g_buffDescTable[1].STAT.KEN = 0; // keep enable bit
g_buffDescTable[1].STAT.INCDIS = 0; // address increment disable bit
g_buffDescTable[1].STAT.DTSEN = 1; // data toggle synch enable bit
g_buffDescTable[1].STAT.BSTALL = 0; // buffer stall enable bit
g_buffDescTable[1].STAT.BC9 = 0; // byte count 9 bit
g_buffDescTable[1].STAT.BC8 = 0; // byte count 8 bit
g_buffDescTable[1].STAT.UOWN = 1; // UOWN bit (SIE owns buffer)
} else {
g_buffDescTable[1].STAT.DTS = 0; // data toggle synch bit
g_buffDescTable[1].STAT.KEN = 0; // keep enable bit
g_buffDescTable[1].STAT.INCDIS = 0; // address increment disable bit
g_buffDescTable[1].STAT.DTSEN = 1; // data toggle synch enable bit
g_buffDescTable[1].STAT.BSTALL = 0; // buffer stall enable bit
g_buffDescTable[1].STAT.BC9 = 0; // byte count 9 bit
g_buffDescTable[1].STAT.BC8 = 0; // byte count 8 bit
g_buffDescTable[1].STAT.UOWN = 1; // UOWN bit (SIE owns buffer)
}
}
} else {
USBPrepareForNextSetupTransfer();
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void USBControlTransferReceive(void) {
BYTE byteToRead;
BYTE i;
byteToRead = g_buffDescTable[0].CNT;
if(byteToRead > g_outPipe.wCount) {
byteToRead = g_outPipe.wCount;
} else {
g_outPipe.wCount = g_outPipe.wCount - byteToRead;
}
for(i=0;i<byteToRead;i++) {
*g_outPipe.bRam++ = g_ctrlTrfData[i];
}
if(g_outPipe.wCount > 0) {
g_buffDescTable[0].CNT = USB_EP0_BUFF_SIZE;
g_buffDescTable[0].ADR = (BYTE*)&g_ctrlTrfData;
if(g_buffDescTable[0].STAT.DTS == 0) {
g_buffDescTable[0].STAT.DTS = 1; // data toggle synch bit
g_buffDescTable[0].STAT.KEN = 0; // keep enable bit
g_buffDescTable[0].STAT.INCDIS = 0; // address increment disable bit
g_buffDescTable[0].STAT.DTSEN = 1; // data toggle synch enable bit
g_buffDescTable[0].STAT.BSTALL = 0; // buffer stall enable bit
g_buffDescTable[0].STAT.BC9 = 0; // byte count 9 bit
g_buffDescTable[0].STAT.BC8 = 0; // byte count 8 bit
g_buffDescTable[0].STAT.UOWN = 1; // UOWN bit (SIE owns buffer)
} else {
g_buffDescTable[0].STAT.DTS = 0; // data toggle synch bit
g_buffDescTable[0].STAT.KEN = 0; // keep enable bit
g_buffDescTable[0].STAT.INCDIS = 0; // address increment disable bit
g_buffDescTable[0].STAT.DTSEN = 1; // data toggle synch enable bit
g_buffDescTable[0].STAT.BSTALL = 0; // buffer stall enable bit
g_buffDescTable[0].STAT.BC9 = 0; // byte count 9 bit
g_buffDescTable[0].STAT.BC8 = 0; // byte count 8 bit
g_buffDescTable[0].STAT.UOWN = 1; // UOWN bit (SIE owns buffer)
}
} else {
g_buffDescTable[0].ADR = (BYTE*)&g_ctrlTrfSetupPkt;
g_outPipe.busy = 0;
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void USBControlTransferTransmit(void) {
WORD_STRUCT byteToSend;
BYTE *pDestination;
if(g_inPipe.wCount < USB_EP0_BUFF_SIZE) {
byteToSend.wordVal = g_inPipe.wCount;
if(g_shortPacketStatus == SHORT_PKT_NOT_USED) {
g_shortPacketStatus = SHORT_PKT_PENDING;
} else if(g_shortPacketStatus == SHORT_PKT_PENDING) {
g_shortPacketStatus = SHORT_PKT_SENT;
}
} else {
byteToSend.wordVal = USB_EP0_BUFF_SIZE;
}
g_buffDescTable[1].STAT.BC9 = 0; // copy value in byteToSend into COUNT
g_buffDescTable[1].STAT.BC8 = 0;
g_buffDescTable[1].STAT.STATVal |= byteToSend.byte.HB;
g_buffDescTable[1].CNT = byteToSend.byte.LB;
g_inPipe.wCount = g_inPipe.wCount - byteToSend.wordVal;
pDestination = (BYTE*)g_ctrlTrfData;
while(byteToSend.wordVal) { // for each byte we have to send . . .
*pDestination = *g_inPipe.bRom; // assign contents of in pipe into g_ctrlTrfData
*pDestination++; // increment one pointer
*g_inPipe.bRom++; // increment other pointer
byteToSend.wordVal--; // decrement counter
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void USBPrepareForNextSetupTransfer(void) {
if((g_controlTransferState == CTRL_TRF_RX) &&
(UCONbits.PKTDIS == 1) &&
(g_buffDescTable[0].CNT == sizeof(CTRL_TRF_SETUP)) &&
(g_buffDescTable[0].STAT.PID == SETUP_TOKEN) &&
(g_buffDescTable[0].STAT.UOWN == 0)) {
BYTE setup_cnt;
g_buffDescTable[0].ADR = (BYTE*)&g_ctrlTrfSetupPkt;
for(setup_cnt = 0; setup_cnt < sizeof(CTRL_TRF_SETUP); setup_cnt++) {
*(((BYTE*)&g_ctrlTrfSetupPkt) + setup_cnt) = *(((BYTE*)&g_ctrlTrfData) + setup_cnt);
}
} else {
g_controlTransferState = CTRL_TRF_WAIT_SETUP;
g_buffDescTable[0].CNT = USB_EP0_BUFF_SIZE;
g_buffDescTable[0].ADR = (BYTE*)&g_ctrlTrfSetupPkt;
g_buffDescTable[0].STAT.DTS = 0; // data toggle synch bit
g_buffDescTable[0].STAT.KEN = 0; // keep enable bit
g_buffDescTable[0].STAT.INCDIS = 0; // address increment disable bit
g_buffDescTable[0].STAT.DTSEN = 1; // data toggle synch enable bit
g_buffDescTable[0].STAT.BSTALL = 1; // buffer stall enable bit
g_buffDescTable[0].STAT.BC9 = 0; // byte count 9 bit
g_buffDescTable[0].STAT.BC8 = 0; // byte count 8 bit
g_buffDescTable[0].STAT.UOWN = 1; // UOWN bit (SIE owns buffer)
g_buffDescTable[1].STAT.UOWN = 0; // UOWN bit (CPU owns buffer)
g_buffDescTable[1].STAT.DTS = 0; // data toggle synch bit
g_buffDescTable[1].STAT.KEN = 0; // keep enable bit
g_buffDescTable[1].STAT.INCDIS = 0; // address increment disable bit
g_buffDescTable[1].STAT.DTSEN = 0; // data toggle synch enable bit
g_buffDescTable[1].STAT.BSTALL = 0; // buffer stall enable bit
g_buffDescTable[1].STAT.BC9 = 0; // byte count 9 bit
g_buffDescTable[1].STAT.BC8 = 0; // byte count 8 bit
}
if(g_outPipe.busy == 1) {
g_outPipe.busy = 0;
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void receiveViaUSB(void) {
while(UIRbits.TRNIF != 1) { } // wait here until any pending transactions are complete
if(g_buffDescTable[2].STAT.UOWN == 0) { // verify USB circuitry does not own from host USB buffer
transferFromHostToDeviceViaEP1((BYTE*)&g_fromHostToDeviceBuffer[1], 64); // get packet from host
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void sendViaUSB(void) {
while(UIRbits.TRNIF != 1) { } // wait here until any pending transactions are complete
if(g_buffDescTable[3].STAT.UOWN == 0) { // verify USB circuitry does not own to host USB buffer
transferFromDeviceToHostViaEP1((BYTE*)&g_fromDeviceToHostBuffer[1], 64); // send packet to host
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void transferFromHostToDeviceViaEP1(BYTE* pPacketData, BYTE packetLength) {
g_buffDescTable[2].STAT.DTS = !g_buffDescTable[2].STAT.DTS; // toggle the data toggle synch bit
g_buffDescTable[2].STAT.KEN = 0; // clear keep enable bit
g_buffDescTable[2].STAT.INCDIS = 0; // clear address increment disable bit
g_buffDescTable[2].STAT.DTSEN = 1; // set data toggle synch enable bit
g_buffDescTable[2].STAT.BSTALL = 0; // clear buffer stall enable bit
g_buffDescTable[2].STAT.BC9 = 0; // clear byte count 9 bit
g_buffDescTable[2].STAT.BC8 = 0; // clear byte count 8 bit
g_buffDescTable[2].STAT.UOWN = 1; // set UOWN bit (SIE owns buffer)
g_buffDescTable[2].CNT = packetLength;
g_buffDescTable[2].ADR = pPacketData;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void transferFromDeviceToHostViaEP1(BYTE* pPacketData, BYTE packetLength) {
g_buffDescTable[3].STAT.DTS = !g_buffDescTable[3].STAT.DTS; // toggle the data toggle synch bit
g_buffDescTable[3].STAT.KEN = 0; // clear keep enable bit
g_buffDescTable[3].STAT.INCDIS = 0; // clear address increment disable bit
g_buffDescTable[3].STAT.DTSEN = 1; // set data toggle synch enable bit
g_buffDescTable[3].STAT.BSTALL = 0; // clear buffer stall enable bit
g_buffDescTable[3].STAT.BC9 = 0; // clear byte count 9 bit
g_buffDescTable[3].STAT.BC8 = 0; // clear byte count 8 bit
g_buffDescTable[3].STAT.UOWN = 1; // set UOWN bit (SIE owns buffer)
g_buffDescTable[3].CNT = packetLength;
g_buffDescTable[3].ADR = pPacketData;
}// USBFunctions.h
// #defines, typedefs, structs ////////////////////////////////////////////////////////////////////
// USB device states - use with g_USBDeviceState (BYTE data type)
#define DETACHED_STATE 0x00
#define ATTACHED_STATE 0x01
#define POWERED_STATE 0x02
#define DEFAULT_STATE 0x04
#define ADR_PENDING_STATE 0x08
#define ADDRESS_STATE 0x10
#define CONFIGURED_STATE 0x20
// for use with g_controlTransferState
#define CTRL_TRF_WAIT_SETUP 0
#define CTRL_TRF_TX 1
#define CTRL_TRF_RX 2
// for use with g_shortPacketStatus
#define SHORT_PKT_NOT_USED 0
#define SHORT_PKT_PENDING 1
#define SHORT_PKT_SENT 2
// for use with g_ctrlTrfSetupPkt.bDescriptorType
#define USB_DESCRIPTOR_DEVICE 0x01
#define USB_DESCRIPTOR_CONFIGURATION 0x02
#define USB_DESCRIPTOR_STRING 0x03
#define USB_DESCRIPTOR_INTERFACE 0x04
#define USB_DESCRIPTOR_ENDPOINT 0x05
#define USB_DESCRIPTOR_DEVICE_QUALIFIER 0x06
#define USB_DESCRIPTOR_OTHER_SPEED 0x07
#define USB_DESCRIPTOR_INTERFACE_POWER 0x08
#define USB_DESCRIPTOR_OTG 0x09
typedef enum _BOOL { FALSE = 0, TRUE = 1 } BOOL;
#define NULL 0
typedef unsigned char BYTE; // unsigned 8-bit int
typedef unsigned short WORD; // unsigned 16-bit int
typedef unsigned long UINT32; // unsigned 32-bit int
typedef unsigned long long UINT64; // unsigned 64-bit int
typedef union _WORD_VAL { // 2 bytes
WORD wordVal;
struct {
BYTE LB;
BYTE HB;
} byte;
} WORD_STRUCT;
typedef struct _USB_DEVICE_DESCRIPTOR {
BYTE bLength;
BYTE bDescriptorType;
WORD bcdUSB;
BYTE bDeviceClass;
BYTE bDeviceSubClass;
BYTE bDeviceProtocol;
BYTE bMaxPacketSize0;
WORD idVendor;
WORD idProduct;
WORD bcdDevice;
BYTE iManufacturer;
BYTE iProduct;
BYTE iSerialNumber;
BYTE bNumConfigurations;
} USB_DEVICE_DESCRIPTOR;
typedef struct _USB_HID_DSC {
BYTE bLength;
BYTE bDescriptorType;
WORD bcdHID;
BYTE bCountryCode;
BYTE bNumDsc;
} USB_HID_DSC;
typedef struct { // 4 bytes
union { // BDnSTAT imitation
struct { // CPU mode (UOWN == 0)
unsigned BC8:1;
unsigned BC9:1;
unsigned BSTALL:1;
unsigned DTSEN:1;
unsigned INCDIS:1;
unsigned KEN:1;
unsigned DTS:1;
unsigned UOWN:1;
};
struct {
unsigned BC8:1; // SIE mode (UOWN == 1)
unsigned BC9:1;
unsigned PID:4;
unsigned :1;
unsigned UOWN:1;
};
BYTE STATVal;
} STAT;
BYTE CNT; // size of buffer in bytes
BYTE *ADR;
} BDT_ENTRY;
#define USB_EP0_BUFF_SIZE 8
#define HID_INTERFACE_ID 0x00
#define HID_NUM_OF_DSC 1 // for use with config descriptor only
#define HID_RPT01_SIZE 29 // HID report 1 size in bytes, used with descriptors only
#define _EP_IN 0x80 // for use with descriptor declarations only
#define _EP_OUT 0x00 //
// configuration attributes
#define _DEFAULT (0x01 << 7) // default value, bit 7 is set used with descriptor declarations only
#define _SELF (0x01 << 6) // self-powered (supports if set) why are these done as bit shifts ??!!
#define _RWU (0x01 << 5) // remote wakeup (supports if set)
// endpoint transfer type, for use with config descriptor only
#define _CTRL 0x00 // control transfer
#define _ISO 0x01 // isochronous transfer
#define _BULK 0x02 // bulk transfer
#define _INT 0x03 // interrupt transfer
// HID interface class code, for use with config descriptor only
#define HID_INTF 0x03
// every setup packet has 8 bytes, this structure allows direct access to the various members of the control transfer
typedef union _CTRL_TRF_SETUP { // 8 bytes
struct {
BYTE bmRequestType; // bit map request type
BYTE bRequest;
WORD wValue;
WORD wIndex;
WORD wLength;
};
struct {
unsigned Recipient:5;
unsigned RequestType:2;
unsigned DataDir:1;
unsigned :8;
unsigned :8;
unsigned :8;
unsigned :8;
unsigned :8;
unsigned :8;
unsigned :8;
};
struct {
unsigned :8;
unsigned :8;
BYTE bDscIndex;
BYTE bDescriptorType;
WORD wLangID;
unsigned :8;
unsigned :8;
};
struct {
unsigned :8;
unsigned :8;
BYTE bDevADR;
BYTE bDevADRH;
unsigned :8;
unsigned :8;
unsigned :8;
unsigned :8;
};
struct {
unsigned :8;
unsigned :8;
BYTE bConfigurationValue;
BYTE bCfgRSD;
unsigned :8;
unsigned :8;
unsigned :8;
unsigned :8;
};
} CTRL_TRF_SETUP;
// pipe structure, used to keep track of data that is sent out of the stack automatically
typedef struct { // 7 bytes
rom BYTE *bRom;
rom WORD *wRom;
BYTE busy;
WORD wCount;
} IN_PIPE;
typedef struct { // 5 bytes
BYTE *bRam;
BYTE busy;
WORD wCount;
} OUT_PIPE;
// for use with g_crtlTrfSetupPkt.bRequest, see USB 2.0 spec. table 9-3
#define GET_STATUS 0
#define CLEAR_FEATURE 1
#define SET_FEATURE 3
#define SET_ADDRESS 5
#define GET_DESCRIPTOR 6
#define SET_DESCRIPTOR 7
#define GET_CONFIGURATION 8
#define SET_CONFIGURATION 9
#define GET_INTERFACE 10
#define SET_INTERFACE 11
#define SYNCH_FRAME 12
// for use with g_buffDescTable.STAT.PID, note that number is 4-bit
#define SETUP_TOKEN 0b1101 // 13 base 10
#define OUT_TOKEN 0b0001 // 1 base 10
#define IN_TOKEN 0b1001 // 9 base 10
// for use with g_ctrlTrfSetupPkt.DataDir
#define HOST_TO_DEV 0
#define DEV_TO_HOST 1
// for use with CTRL_TRF_SETUP.RequestType
#define STANDARD 0x00
#define CLASS 0x01
#define VENDOR 0x02
// for use with g_ctrlTrfSetupPkt.Recipient
#define RECIPIENT_DEVICE 0
#define RECIPIENT_INTERFACE 1
#define RECIPIENT_ENDPOINT 2
#define RECIPIENT_OTHER 3
// for use with g_ctrlTrfSetupPkt.bRequest
#define GET_REPORT 0x01
#define GET_IDLE 0x02
#define GET_PROTOCOL 0x03
#define SET_REPORT 0x09
#define SET_IDLE 0x0A
#define SET_PROTOCOL 0x0B
// for use with g_ctrlTrfSetupPkt.bDescriptorType, and also in descriptor declarations
#define HID_DESCRIPTOR 0x21
#define REPORT_DESCRIPTOR 0x22
#define PHY_DESCRIPTOR 0x23
#define CLK_FREQ 48000000
// function prototypes ////////////////////////////////////////////////////////////////////////////
void USBInit(void);
void USBTasks(void);
void USBWakeFromSuspend(void);
void USBSuspend(void);
void USBStallHandler(void);
void USBEP0ControlTransfer(void);
void USBSetupControlTransfer(void);
void USBOutControlTransfer(void);
void USBInControlTransfer(void);
void USBCheckStandardRequest(void);
void USBCheckHIDRequest(void);
void USBFinishControlTransferStuff(void);
void USBControlTransferReceive(void);
void USBControlTransferTransmit(void);
void USBPrepareForNextSetupTransfer(void);
void receiveViaUSB(void);
void sendViaUSB(void);
void transferFromHostToDeviceViaEP1(BYTE* pPacketData, BYTE packetLength);
void transferFromDeviceToHostViaEP1(BYTE* pPacketData, BYTE packetLength);// File: Application_18f4550.lkr
// Use this linker for the USB application that will be self programmed by the HID bootloader.
// The HID bootloader project itself uses the BootModified.18f4450.lkr file instead.
// THIS LINKER SCRIPT HAS BEEN MODIFIED... This version is intended to be used
// with the "PROGRAMMABLE_WITH_USB_HID_BOOTLOADER" bootloader. The HID
// bootloader occupies memory ranges 0x000-0xFFF. In order for the code generated
// by this project to work with the bootloader, the linker must not put any code
// in the 0x00-0xFFF address range.
// This linker script was originated from the 18f4550.lkr file provided by
// the MCC18 distribution.
LIBPATH .
FILES c018i.o
FILES clib.lib
FILES p18f4550.lib
CODEPAGE NAME=bootloader START=0x0 END=0xFFF PROTECTED
CODEPAGE NAME=vectors START=0x1000 END=0x1029 PROTECTED
CODEPAGE NAME=page START=0x102A END=0x7FFF
CODEPAGE NAME=idlocs START=0x200000 END=0x200007 PROTECTED
CODEPAGE NAME=config START=0x300000 END=0x30000D PROTECTED
CODEPAGE NAME=devid START=0x3FFFFE END=0x3FFFFF PROTECTED
CODEPAGE NAME=eedata START=0xF00000 END=0xF000FF PROTECTED
ACCESSBANK NAME=accessram START=0x0 END=0x5F
DATABANK NAME=gpr0 START=0x60 END=0xFF
DATABANK NAME=gpr1 START=0x100 END=0x1FF
DATABANK NAME=gpr2 START=0x200 END=0x2FF
DATABANK NAME=gpr3 START=0x300 END=0x3FF
DATABANK NAME=usb4 START=0x400 END=0x4FF PROTECTED
DATABANK NAME=usb5 START=0x500 END=0x5FF PROTECTED
DATABANK NAME=usb6 START=0x600 END=0x6FF PROTECTED
DATABANK NAME=usb7 START=0x700 END=0x7FF PROTECTED
ACCESSBANK NAME=accesssfr START=0xF60 END=0xFFF PROTECTED
SECTION NAME=CONFIG ROM=config
STACK SIZE=0x100 RAM=gpr3
SECTION NAME=USB_VARS RAM=usb4/*
Notes on using this class:
1) To get a successfull compile, it is necessary to go to:
Project -> [project name] Properties -> Build -> check 'Allow Unsafe Code'
2) change the namespace name to match your project
*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Microsoft.Win32.SafeHandles;
using System.Runtime.InteropServices;
using System.Threading;
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace USBMotorController { // NOTE: change this to match your namespace name
/////////////////////////////////////////////////////////////////////////////////////////////////
public class USBClass : Form {
//
// constants //////////////////////////////////////////////////////////////////////////////////
public const byte CONNECTION_NOT_SUCCESSFUL = 0; // for use with g_connectionState
public const byte CONNECTION_SUCCESSFUL = 1; //
// constant definitions from setupapi.h, which we aren't allowed to include directly since this is C#
internal const uint DIGCF_PRESENT = 0x02;
internal const uint DIGCF_DEVICEINTERFACE = 0x10;
// constants for CreateFile() and other file I/O functions
internal const short FILE_ATTRIBUTE_NORMAL = 0x80;
internal const short INVALID_HANDLE_VALUE = -1;
internal const uint GENERIC_READ = 0x80000000;
internal const uint GENERIC_WRITE = 0x40000000;
internal const uint CREATE_NEW = 1;
internal const uint CREATE_ALWAYS = 2;
internal const uint OPEN_EXISTING = 3;
internal const uint FILE_SHARE_READ = 0x00000001;
internal const uint FILE_SHARE_WRITE = 0x00000002;
// constant definitions for certain WM_DEVICECHANGE messages
internal const uint WM_DEVICECHANGE = 0x0219;
internal const uint DBT_DEVICEARRIVAL = 0x8000;
internal const uint DBT_DEVICEREMOVEPENDING = 0x8003;
internal const uint DBT_DEVICEREMOVECOMPLETE = 0x8004;
internal const uint DBT_CONFIGCHANGED = 0x0018;
// other constant definitions
internal const uint DBT_DEVTYP_DEVICEINTERFACE = 0x05;
internal const uint DEVICE_NOTIFY_WINDOW_HANDLE = 0x00;
internal const uint DEVICE_NOTIFY_SERVICE_HANDLE = 0x01;
internal const uint DEVICE_NOTIFY_ALL_INTERFACE_CLASSES = 0x04;
internal const uint ERROR_SUCCESS = 0x00;
internal const uint ERROR_NO_MORE_ITEMS = 0x00000103;
internal const uint SPDRP_HARDWAREID = 0x00000001;
// structs ////////////////////////////////////////////////////////////////////////////////////
// struct definitions from setupapi.h, which we aren't allowed to include directly since this is C#
internal struct SP_DEVICE_INTERFACE_DATA
{
internal uint cbSize; //DWORD
internal Guid InterfaceClassGuid; //GUID
internal uint Flags; //DWORD
internal uint Reserved; //ULONG_PTR MSDN says ULONG_PTR is "typedef unsigned __int3264 ULONG_PTR;"
}
internal struct SP_DEVICE_INTERFACE_DETAIL_DATA
{
internal uint cbSize; //DWORD
internal char[] DevicePath; //TCHAR array of any size
}
internal struct SP_DEVINFO_DATA
{
internal uint cbSize; //DWORD
internal Guid ClassGuid; //GUID
internal uint DevInst; //DWORD
internal uint Reserved; //ULONG_PTR MSDN says ULONG_PTR is "typedef unsigned __int3264 ULONG_PTR;"
}
internal struct DEV_BROADCAST_DEVICEINTERFACE
{
internal uint dbcc_size; //DWORD
internal uint dbcc_devicetype; //DWORD
internal uint dbcc_reserved; //DWORD
internal Guid dbcc_classguid; //GUID
internal char[] dbcc_name; //TCHAR array
}
// Windows API function DLL imports ///////////////////////////////////////////////////////////
//Returns a HDEVINFO type for a device information set. We will need the
//HDEVINFO as in input parameter for calling many of the other SetupDixxx() functions.
[DllImport("setupapi.dll", SetLastError = true, CharSet = CharSet.Unicode)]
internal static extern IntPtr SetupDiGetClassDevs(ref Guid ClassGuid, //LPGUID Input: Need to supply the class GUID.
IntPtr Enumerator, //PCTSTR Input: Use NULL here, not important for our purposes
IntPtr hwndParent, //HWND Input: Use NULL here, not important for our purposes
uint Flags); //DWORD Input: Flags describing what kind of filtering to use.
//Gives us "PSP_DEVICE_INTERFACE_DATA" which contains the Interface specific GUID (different
//from class GUID). We need the interface GUID to get the device path.
[DllImport("setupapi.dll", SetLastError = true, CharSet = CharSet.Unicode)]
internal static extern bool SetupDiEnumDeviceInterfaces(IntPtr DeviceInfoSet, //Input: Give it the HDEVINFO we got from SetupDiGetClassDevs()
IntPtr DeviceInfoData, //Input (optional)
ref Guid InterfaceClassGuid, //Input
uint MemberIndex, //Input: "Index" of the device you are interested in getting the path for.
ref SP_DEVICE_INTERFACE_DATA DeviceInterfaceData); //Output: This function fills in an "SP_DEVICE_INTERFACE_DATA" structure.
//SetupDiDestroyDeviceInfoList() frees up memory by destroying a DeviceInfoList
[DllImport("setupapi.dll", SetLastError = true, CharSet = CharSet.Unicode)]
internal static extern bool SetupDiDestroyDeviceInfoList(IntPtr DeviceInfoSet); //Input: Give it a handle to a device info list to deallocate from RAM.
//SetupDiEnumDeviceInfo() fills in an "SP_DEVINFO_DATA" structure, which we need for SetupDiGetDeviceRegistryProperty()
[DllImport("setupapi.dll", SetLastError = true, CharSet = CharSet.Unicode)]
internal static extern bool SetupDiEnumDeviceInfo(IntPtr DeviceInfoSet,
uint MemberIndex,
ref SP_DEVINFO_DATA DeviceInterfaceData);
//SetupDiGetDeviceRegistryProperty() gives us the hardware ID, which we use to check to see if it has matching VID/PID
[DllImport("setupapi.dll", SetLastError = true, CharSet = CharSet.Unicode)]
internal static extern bool SetupDiGetDeviceRegistryProperty(IntPtr DeviceInfoSet,
ref SP_DEVINFO_DATA DeviceInfoData,
uint Property,
ref uint PropertyRegDataType,
IntPtr PropertyBuffer,
uint PropertyBufferSize,
ref uint RequiredSize);
//SetupDiGetDeviceInterfaceDetail() gives us a device path, which is needed before CreateFile() can be used.
[DllImport("setupapi.dll", SetLastError = true, CharSet = CharSet.Unicode)]
internal static extern bool SetupDiGetDeviceInterfaceDetail(IntPtr DeviceInfoSet, //Input: Wants HDEVINFO which can be obtained from SetupDiGetClassDevs()
ref SP_DEVICE_INTERFACE_DATA DeviceInterfaceData, //Input: Pointer to an structure which defines the device interface.
IntPtr DeviceInterfaceDetailData, //Output: Pointer to a SP_DEVICE_INTERFACE_DETAIL_DATA structure, which will receive the device path.
uint DeviceInterfaceDetailDataSize, //Input: Number of bytes to retrieve.
ref uint RequiredSize, //Output (optional): The number of bytes needed to hold the entire struct
IntPtr DeviceInfoData); //Output (optional): Pointer to a SP_DEVINFO_DATA structure
//Overload for SetupDiGetDeviceInterfaceDetail(). Need this one since we can't pass NULL pointers directly in C#.
[DllImport("setupapi.dll", SetLastError = true, CharSet = CharSet.Unicode)]
internal static extern bool SetupDiGetDeviceInterfaceDetail(IntPtr DeviceInfoSet, //Input: Wants HDEVINFO which can be obtained from SetupDiGetClassDevs()
ref SP_DEVICE_INTERFACE_DATA DeviceInterfaceData, //Input: Pointer to an structure which defines the device interface.
IntPtr DeviceInterfaceDetailData, //Output: Pointer to a SP_DEVICE_INTERFACE_DETAIL_DATA structure, which will contain the device path.
uint DeviceInterfaceDetailDataSize, //Input: Number of bytes to retrieve.
IntPtr RequiredSize, //Output (optional): Pointer to a DWORD to tell you the number of bytes needed to hold the entire struct
IntPtr DeviceInfoData); //Output (optional): Pointer to a SP_DEVINFO_DATA structure
//Need this function for receiving all of the WM_DEVICECHANGE messages. See MSDN documentation for
//description of what this function does/how to use it. Note: name is remapped "RegisterDeviceNotificationUM" to
//avoid possible build error conflicts.
[DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
internal static extern IntPtr RegisterDeviceNotification(IntPtr hRecipient,
IntPtr NotificationFilter,
uint Flags);
//Takes in a device path and opens a handle to the device.
[DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
static extern SafeFileHandle CreateFile(string lpFileName,
uint dwDesiredAccess,
uint dwShareMode,
IntPtr lpSecurityAttributes,
uint dwCreationDisposition,
uint dwFlagsAndAttributes,
IntPtr hTemplateFile);
//Uses a handle (created with CreateFile()), and lets us write USB data to the device.
[DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
static extern bool WriteFile(SafeFileHandle hFile,
byte[] lpBuffer,
uint nNumberOfBytesToWrite,
ref uint lpNumberOfBytesWritten,
IntPtr lpOverlapped);
//Uses a handle (created with CreateFile()), and lets us read USB data from the device.
[DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
static extern bool ReadFile(SafeFileHandle hFile,
IntPtr lpBuffer,
uint nNumberOfBytesToRead,
ref uint lpNumberOfBytesRead,
IntPtr lpOverlapped);
// member variables ///////////////////////////////////////////////////////////////////////////
// modify to match the Vendor ID (VID) and Product ID (PID) in the firmware USB Device Descriptor
// default is set to match the Microchip examples
public String deviceID = "Vid_04D8&Pid_003F"; // use the format "Vid_xxxx&Pid_xxxx" where xxxx is a 16-bit hex number
public int connectionState; // for USB connection state
public byte[] fromDeviceToHostBuffer = new byte[65]; // for data transfer to host, byte 0 => "Report ID", init to zero and never use !!
public byte[] fromHostToDeviceBuffer = new byte[65]; // for data transfer to device, byte 0 => "Report ID", init to zero and never use !!
bool AttachedState = false; //Need to keep track of the USB device attachment status for proper plug and play operation.
SafeFileHandle WriteHandleToUSBDevice = null;
SafeFileHandle ReadHandleToUSBDevice = null;
String DevicePath = null; //Need the find the proper device path before you can open file handles.
//Globally Unique Identifier (GUID) for HID class devices. Windows uses GUIDs to identify things.
Guid InterfaceClassGuid = new Guid(0x4d1e55b2, 0xf16f, 0x11cf, 0x88, 0xcb, 0x00, 0x11, 0x11, 0x00, 0x00, 0x30);
// constructor ////////////////////////////////////////////////////////////////////////////////
public USBClass()
{
fromHostToDeviceBuffer[0] = 0; // The first byte in the I/O buffers is the "Report ID" and does not get transmitted over the
fromDeviceToHostBuffer[0] = 0; // USB bus, never change these !!! Start using the buffers for actual data at index 1.
}
///////////////////////////////////////////////////////////////////////////////////////////////////
public int attemptUSBConnection()
{
// Register for WM_DEVICECHANGE notifications. This code uses these messages to detect plug and play connection/disconnection events for USB devices
DEV_BROADCAST_DEVICEINTERFACE DeviceBroadcastHeader = new DEV_BROADCAST_DEVICEINTERFACE();
DeviceBroadcastHeader.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
DeviceBroadcastHeader.dbcc_size = (uint)Marshal.SizeOf(DeviceBroadcastHeader);
DeviceBroadcastHeader.dbcc_reserved = 0; //Reserved says not to use...
DeviceBroadcastHeader.dbcc_classguid = InterfaceClassGuid;
// Need to get the address of the DeviceBroadcastHeader to call RegisterDeviceNotification(), but
// can't use "&DeviceBroadcastHeader". Instead, using a roundabout means to get the address by
// making a duplicate copy using Marshal.StructureToPtr().
IntPtr pDeviceBroadcastHeader = IntPtr.Zero; // Make a pointer.
pDeviceBroadcastHeader = Marshal.AllocHGlobal(Marshal.SizeOf(DeviceBroadcastHeader)); // allocate memory for a new DEV_BROADCAST_DEVICEINTERFACE structure, and return the address
Marshal.StructureToPtr(DeviceBroadcastHeader, pDeviceBroadcastHeader, false); // Copies the DeviceBroadcastHeader structure into the memory already allocated at DeviceBroadcastHeaderWithPointer
RegisterDeviceNotification(this.Handle, pDeviceBroadcastHeader, DEVICE_NOTIFY_WINDOW_HANDLE);
// Now make an initial attempt to find the USB device, if it was already connected to the PC and enumerated prior to launching the application.
// If it is connected and present, we should open read and write handles to the device so we can communicate with it later.
// If it was not connected, we will have to wait until the user plugs the device in, and the WM_DEVICECHANGE callback function can process
// the message and again search for the device.
IntPtr DeviceInfoTable = IntPtr.Zero;
SP_DEVICE_INTERFACE_DATA InterfaceDataStructure = new SP_DEVICE_INTERFACE_DATA();
SP_DEVICE_INTERFACE_DETAIL_DATA DetailedInterfaceDataStructure = new SP_DEVICE_INTERFACE_DETAIL_DATA();
SP_DEVINFO_DATA DevInfoData = new SP_DEVINFO_DATA();
uint InterfaceIndex = 0;
uint dwRegType = 0;
uint dwRegSize = 0;
uint dwRegSize2 = 0;
uint StructureSize = 0;
IntPtr PropertyValueBuffer = IntPtr.Zero;
bool MatchFound = false;
uint ErrorStatus;
uint loopCounter = 0;
String DeviceIDToFind = deviceID;
// First populate a list of plugged in devices (by specifying "DIGCF_PRESENT"), which are of the specified class GUID.
DeviceInfoTable = SetupDiGetClassDevs(ref InterfaceClassGuid, IntPtr.Zero, IntPtr.Zero, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
if (DeviceInfoTable == IntPtr.Zero) return (CONNECTION_NOT_SUCCESSFUL);
// Now look through the list we just populated. We are trying to see if any of them match our device.
while (true)
{
InterfaceDataStructure.cbSize = (uint)Marshal.SizeOf(InterfaceDataStructure);
if (SetupDiEnumDeviceInterfaces(DeviceInfoTable, IntPtr.Zero, ref InterfaceClassGuid, InterfaceIndex, ref InterfaceDataStructure))
{
ErrorStatus = (uint)Marshal.GetLastWin32Error();
if (ErrorStatus == ERROR_NO_MORE_ITEMS)
{ // did we reach the end of the list of matching devices in the DeviceInfoTable?
// cound not find the device. Must not have been attached.
SetupDiDestroyDeviceInfoList(DeviceInfoTable); // clean up the old structure we no longer need.
return (CONNECTION_NOT_SUCCESSFUL);
}
}
else
{ // else some other kind of unknown error ocurred...
ErrorStatus = (uint)Marshal.GetLastWin32Error();
SetupDiDestroyDeviceInfoList(DeviceInfoTable); // Clean up the old structure we no longer need.
return (CONNECTION_NOT_SUCCESSFUL);
}
// Now retrieve the hardware ID from the registry. The hardware ID contains the VID and PID, which we will then
// check to see if it is the correct device or not.
// Initialize an appropriate SP_DEVINFO_DATA structure. We need this structure for SetupDiGetDeviceRegistryProperty().
DevInfoData.cbSize = (uint)Marshal.SizeOf(DevInfoData);
SetupDiEnumDeviceInfo(DeviceInfoTable, InterfaceIndex, ref DevInfoData);
// First query for the size of the hardware ID, so we can know how big a buffer to allocate for the data.
SetupDiGetDeviceRegistryProperty(DeviceInfoTable, ref DevInfoData, SPDRP_HARDWAREID, ref dwRegType, IntPtr.Zero, 0, ref dwRegSize);
// Allocate a buffer for the hardware ID.
// Should normally work, but could throw exception "OutOfMemoryException" if not enough resources available.
PropertyValueBuffer = Marshal.AllocHGlobal((int)dwRegSize);
// Retrieve the hardware IDs for the current device we are looking at. PropertyValueBuffer gets filled with a
// REG_MULTI_SZ (array of null terminated strings). To find a device, we only care about the very first string in the
// buffer, which will be the "device ID". The device ID is a string which contains the VID and PID, in the example
// format "Vid_04d8&Pid_003f".
SetupDiGetDeviceRegistryProperty(DeviceInfoTable, ref DevInfoData, SPDRP_HARDWAREID, ref dwRegType, PropertyValueBuffer, dwRegSize, ref dwRegSize2);
// Now check if the first string in the hardware ID matches the device ID of the USB device we are trying to find.
String DeviceIDFromRegistry = Marshal.PtrToStringUni(PropertyValueBuffer); // Make a new string, fill it with the contents from the PropertyValueBuffer
Marshal.FreeHGlobal(PropertyValueBuffer); // no longer need the PropertyValueBuffer, free the memory to prevent potential memory leaks
// Convert both strings to lower case. This makes the code more robust/portable accross OS Versions
DeviceIDFromRegistry = DeviceIDFromRegistry.ToLowerInvariant();
DeviceIDToFind = DeviceIDToFind.ToLowerInvariant();
// Now check if the hardware ID we are looking at contains the correct VID/PID
MatchFound = DeviceIDFromRegistry.Contains(DeviceIDToFind);
if (MatchFound == true)
{
// Device must have been found. In order to open I/O file handle(s), we will need the actual device path first.
// We can get the path by calling SetupDiGetDeviceInterfaceDetail(), however, we have to call this function twice: The first
// time to get the size of the required structure/buffer to hold the detailed interface data, then a second time to actually
// get the structure (after we have allocated enough memory for the structure.)
DetailedInterfaceDataStructure.cbSize = (uint)Marshal.SizeOf(DetailedInterfaceDataStructure);
// First call populates "StructureSize" with the correct value
SetupDiGetDeviceInterfaceDetail(DeviceInfoTable, ref InterfaceDataStructure, IntPtr.Zero, 0, ref StructureSize, IntPtr.Zero);
// Need to call SetupDiGetDeviceInterfaceDetail() again, this time specifying a pointer to a SP_DEVICE_INTERFACE_DETAIL_DATA buffer with the correct size of RAM allocated.
// First need to allocate the unmanaged buffer and get a pointer to it.
IntPtr pUnmanagedDetailedInterfaceDataStructure = IntPtr.Zero; // Declare a pointer.
pUnmanagedDetailedInterfaceDataStructure = Marshal.AllocHGlobal((int)StructureSize); // Reserve some unmanaged memory for the structure.
DetailedInterfaceDataStructure.cbSize = 6; // Initialize the cbSize parameter (4 bytes for DWORD + 2 bytes for unicode null terminator)
Marshal.StructureToPtr(DetailedInterfaceDataStructure, pUnmanagedDetailedInterfaceDataStructure, false); //Copy managed structure contents into the unmanaged memory buffer.
// Now call SetupDiGetDeviceInterfaceDetail() a second time to receive the device path in the structure at pUnmanagedDetailedInterfaceDataStructure.
if (SetupDiGetDeviceInterfaceDetail(DeviceInfoTable, ref InterfaceDataStructure, pUnmanagedDetailedInterfaceDataStructure, StructureSize, IntPtr.Zero, IntPtr.Zero))
{
// Need to extract the path information from the unmanaged "structure". The path starts at (pUnmanagedDetailedInterfaceDataStructure + sizeof(DWORD)).
IntPtr pToDevicePath = new IntPtr((uint)pUnmanagedDetailedInterfaceDataStructure.ToInt32() + 4); //Add 4 to the pointer (to get the pointer to point to the path, instead of the DWORD cbSize parameter)
DevicePath = Marshal.PtrToStringUni(pToDevicePath); // Now copy the path information into the globally defined DevicePath String.
// We now have the proper device path, and we can finally use the path to open I/O handle(s) to the device.
SetupDiDestroyDeviceInfoList(DeviceInfoTable); // Clean up the old structure we no longer need.
Marshal.FreeHGlobal(pUnmanagedDetailedInterfaceDataStructure); // No longer need this unmanaged SP_DEVICE_INTERFACE_DETAIL_DATA buffer. We already extracted the path information.
uint ErrorStatusWrite;
uint ErrorStatusRead;
// we now have the proper device path, and we can finally open read and write handles to the device.
WriteHandleToUSBDevice = CreateFile(DevicePath, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, IntPtr.Zero, OPEN_EXISTING, 0, IntPtr.Zero);
ErrorStatusWrite = (uint)Marshal.GetLastWin32Error();
ReadHandleToUSBDevice = CreateFile(DevicePath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, IntPtr.Zero, OPEN_EXISTING, 0, IntPtr.Zero);
ErrorStatusRead = (uint)Marshal.GetLastWin32Error();
if ((ErrorStatusWrite == ERROR_SUCCESS) && (ErrorStatusRead == ERROR_SUCCESS))
{
return (CONNECTION_SUCCESSFUL);
}
else
{ // for some reason the device was physically plugged in, but one or both of the read/write handles didn't open successfully...
if (ErrorStatusWrite == ERROR_SUCCESS) WriteHandleToUSBDevice.Close();
if (ErrorStatusRead == ERROR_SUCCESS) ReadHandleToUSBDevice.Close();
return (CONNECTION_NOT_SUCCESSFUL);
}
}
else
{ // Some unknown failure occurred
uint ErrorCode = (uint)Marshal.GetLastWin32Error();
SetupDiDestroyDeviceInfoList(DeviceInfoTable); // Clean up the old structure.
Marshal.FreeHGlobal(pUnmanagedDetailedInterfaceDataStructure); // No longer need this unmanaged SP_DEVICE_INTERFACE_DETAIL_DATA buffer. We already extracted the path information.
return (CONNECTION_NOT_SUCCESSFUL);
}
}
InterfaceIndex++;
loopCounter++;
if (loopCounter > 200)
{ // if more than 200 times through the loop . . .
return (CONNECTION_NOT_SUCCESSFUL); // give up and bail
}
} // end of while(true)
}
///////////////////////////////////////////////////////////////////////////////////////////////
public void receiveViaUSB()
{
uint BytesRead = 0;
ReadFileManagedBuffer(ReadHandleToUSBDevice, fromDeviceToHostBuffer, 65, ref BytesRead, IntPtr.Zero); // get buffer from device
}
///////////////////////////////////////////////////////////////////////////////////////////////
public void sendViaUSB()
{
uint BytesWritten = 0;
WriteFile(WriteHandleToUSBDevice, fromHostToDeviceBuffer, 65, ref BytesWritten, IntPtr.Zero); // send buffer to device
}
///////////////////////////////////////////////////////////////////////////////////////////////
//FUNCTION: ReadFileManagedBuffer()
//PURPOSE: Wrapper function to call ReadFile()
//
//INPUT: Uses managed versions of the same input parameters as ReadFile() uses.
//
//OUTPUT: Returns boolean indicating if the function call was successful or not.
// Also returns data in the byte[] INBuffer, and the number of bytes read.
//
//Notes: Wrapper function used to call the ReadFile() function. ReadFile() takes a pointer to an unmanaged buffer and deposits
// the bytes read into the buffer. However, can't pass a pointer to a managed buffer directly to ReadFile().
// This ReadFileManagedBuffer() is a wrapper function to make it so application code can call ReadFile() easier
// by specifying a managed buffer.
public unsafe bool ReadFileManagedBuffer(SafeFileHandle hFile, byte[] INBuffer, uint nNumberOfBytesToRead, ref uint lpNumberOfBytesRead, IntPtr lpOverlapped)
{
IntPtr pINBuffer = IntPtr.Zero;
try
{
pINBuffer = Marshal.AllocHGlobal((int)nNumberOfBytesToRead); //Allocate some unmanged RAM for the receive data buffer.
if (ReadFile(hFile, pINBuffer, nNumberOfBytesToRead, ref lpNumberOfBytesRead, lpOverlapped))
{
Marshal.Copy(pINBuffer, INBuffer, 0, (int)lpNumberOfBytesRead); //Copy over the data from unmanged memory into the managed byte[] INBuffer
Marshal.FreeHGlobal(pINBuffer);
return true;
}
else
{
Marshal.FreeHGlobal(pINBuffer);
return false;
}
}
catch
{
if (pINBuffer != IntPtr.Zero)
{
Marshal.FreeHGlobal(pINBuffer);
} return (false);
}
}
} // end class
} // end namespace