void usb_msc_start (void) {
debug("Initialising USB stack");
// initialise stack
USBInit();
// enable bulk-in interrupts on NAKs
// these are required to get the BOT protocol going again after a STALL
USBHwNakIntEnable(INACK_BI);
// register descriptors
USBRegisterDescriptors(abDescriptors);
// register class request handler
USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData);
// register endpoint handlers
USBHwRegisterEPIntHandler(MSC_BULK_IN_EP, MSCBotBulkIn);
USBHwRegisterEPIntHandler(MSC_BULK_OUT_EP, MSCBotBulkOut);
debug("Starting USB communication");
// connect to bus
USBHwConnect(true);
// call USB interrupt handler continuously
while (1) {
USBHwISR();
}
}
int ubertooth_usb_init(VendorRequestHandler *vendor_req_handler)
{
// initialise stack
USBInit();
// register device descriptors
USBRegisterDescriptors(abDescriptors);
// Request handler
v_req_handler = vendor_req_handler;
// override standard request handler
USBRegisterRequestHandler(REQTYPE_TYPE_VENDOR, usb_vendor_request_handler, abVendorReqData);
// register endpoints
//USBHwRegisterEPIntHandler(BULK_IN_EP, usb_bulk_in_handler);
//USBHwRegisterEPIntHandler(BULK_OUT_EP, usb_bulk_out_handler);
// enable USB interrupts
//ISER0 = ISER0_ISE_USB;
// connect to bus
USBHwConnect(TRUE);
return 0;
}
/**
Initialises the USB hardware and sets up the USB stack by
installing default callbacks.
@return TRUE if initialisation was successful
*/
BOOL USBInit(void)
{
// init hardware
USBHwInit();
// Manual reset to workaround silicon bug
USBHwReset();
// Reset USB address
USBHwSetAddress(0);
// register device status interrupt handler
USBHwRegisterDevIntHandler(HandleUsbDevStatus);
// register control transfer handler on EP0
USBHwRegisterEPIntHandler(0x00, USBHandleControlTransfer);
USBHwRegisterEPIntHandler(0x80, USBHandleControlTransfer);
// setup control endpoints
USBHwEPConfig(0x00, MAX_PACKET_SIZE0);
USBHwEPConfig(0x80, MAX_PACKET_SIZE0);
// register standard request handler
USBRegisterRequestHandler(REQTYPE_TYPE_STANDARD, USBHandleStandardRequest, abStdReqData);
return TRUE;
}
void USBSerial_Init(void)
{
// initialise stack
USBInit();
// register descriptors
USBRegisterDescriptors(abDescriptors);
// register class request handler
USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData);
// register endpoint handlers
USBHwRegisterEPIntHandler(INT_IN_EP, NULL);
USBHwRegisterEPIntHandler(BULK_IN_EP, BulkIn);
USBHwRegisterEPIntHandler(BULK_OUT_EP, BulkOut);
// register frame handler
USBHwRegisterFrameHandler(USBFrameHandler);
// enable bulk-in interrupts on NAKs
USBHwNakIntEnable(INACK_BI);
// initialise VCOM
serial_init();
NVIC_EnableIRQ(USB_IRQn);
// connect to bus
USBHwConnect(TRUE);
}
void init_usb_msc_device(void)
{
DBG("Initialising USB stack\n");
// initialise stack
USBInit();
// enable bulk-in interrupts on NAKs
// these are required to get the BOT protocol going again after a STALL
USBHwNakIntEnable(INACK_BI);
// register descriptors
USBRegisterDescriptors(abDescriptors);
// register class request handler
USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData);
// register endpoint handlers
USBHwRegisterEPIntHandler(MSC_BULK_IN_EP, MSCBotBulkIn);
USBHwRegisterEPIntHandler(MSC_BULK_OUT_EP, MSCBotBulkOut);
DBG("Starting USB communication\n");
// connect to bus
USBHwConnect(TRUE);
}
/*
* main
*/
int main(void) {
FIO_ENABLE;
pllstart_seventytwomhz() ;
mam_enable();
uart0_init_115200() ;
DBG(UART0,"Initialising USB stack\n");
// initialise stack
USBInit();
// register descriptors
USBRegisterDescriptors(abDescriptors);
// register class request handler
USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData);
// register endpoint handlers
USBHwRegisterEPIntHandler(INT_IN_EP, NULL);
// register frame handler
USBHwRegisterFrameHandler(USBFrameHandler);
// register device event handler
USBHwRegisterDevIntHandler(USBDevIntHandler);
inputIsocDataBuffer[0] = 0;
DBG(UART0,"Starting USB isoc datatpath test\n");
VICVectPriority22 = 0x01;
VICVectAddr22 = (int) USBIntHandler;
// set up USB interrupt
VICIntSelect &= ~(1<<22); // select IRQ for USB
VICIntEnable |= (1<<22);
vic_enableIRQ();
// connect to bus
USBHwConnect(TRUE);
stream_task();
return 0;
}
/*************************************************************************
main
====
**************************************************************************/
int main(void)
{
// PLL and MAM
Initialize();
// init DBG
ConsoleInit(60000000 / (16 * BAUD_RATE));
// initialise the SD card
BlockDevInit();
DBG("Initialising USB stack\n");
// initialise stack
USBInit();
// enable bulk-in interrupts on NAKs
// these are required to get the BOT protocol going again after a STALL
USBHwNakIntEnable(INACK_BI);
// register descriptors
USBRegisterDescriptors(abDescriptors);
// register class request handler
USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData);
// register endpoint handlers
USBHwRegisterEPIntHandler(MSC_BULK_IN_EP, MSCBotBulkIn);
USBHwRegisterEPIntHandler(MSC_BULK_OUT_EP, MSCBotBulkOut);
DBG("Starting USB communication\n");
// connect to bus
USBHwConnect(TRUE);
// call USB interrupt handler continuously
while (1) {
USBHwISR();
}
return 0;
}
/*************************************************************************
USBInit
=======
Initialises the USB hardware and sets up the USB stack by
installing default callbacks.
**************************************************************************/
BOOL USBInit(void)
{
// init hardware
USBHwInit();
// register bus reset handler
USBHwRegisterDevIntHandler(HandleUsbReset);
// register control transfer handler on EP0
USBHwRegisterEPIntHandler(0x00, MAX_PACKET_SIZE0, USBHandleControlTransfer);
USBHwRegisterEPIntHandler(0x80, MAX_PACKET_SIZE0, USBHandleControlTransfer);
// register standard request handler
USBRegisterRequestHandler(REQTYPE_TYPE_STANDARD, USBHandleStandardRequest);
// register
USBRegisterDescriptorHandler(USBHandleDescriptor);
return TRUE;
}
/**
Initialises the USB hardware and sets up the USB stack by
installing default callbacks.
@return TRUE if initialisation was successful
*/
BOOL USBInit(void)
{
// init hardware
USBHwInit();
// register bus reset handler
USBHwRegisterDevIntHandler(HandleUsbReset);
// register control transfer handler on EP0
USBHwRegisterEPIntHandler(0x00, USBHandleControlTransfer);
USBHwRegisterEPIntHandler(0x80, USBHandleControlTransfer);
// setup control endpoints
USBHwEPConfig(0x00, MAX_PACKET_SIZE0);
USBHwEPConfig(0x80, MAX_PACKET_SIZE0);
// register standard request handler
USBRegisterRequestHandler(REQTYPE_TYPE_STANDARD, USBHandleStandardRequest, abStdReqData);
return TRUE;
}
/*************************************************************************
main
====
**************************************************************************/
int main_mass_storage(void)
{
unsigned cpsr;
// disable global interrupts, do it polling
cpsr = disableIRQ();
// initialise the SD card
BlockDevInit();
// initialise stack
USBInit();
// enable bulk-in interrupts on NAKs
// these are required to get the BOT protocol going again after a STALL
USBHwNakIntEnable(INACK_BI);
// register descriptors
USBRegisterDescriptors(abDescriptors);
// register class request handler
USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData);
// register endpoint handlers
USBHwRegisterEPIntHandler(MSC_BULK_IN_EP, MSCBotBulkIn);
USBHwRegisterEPIntHandler(MSC_BULK_OUT_EP, MSCBotBulkOut);
// connect to bus
USBHwConnect(TRUE);
// call USB interrupt handler continuously
while (1) {
USBHwISR();
}
// possibly restore global interrupts (never happens)
restoreIRQ(cpsr);
return 0;
}
void platform_setup_usb_cdc(void)
{
int c;
printf("Initialising USB stack\n");
// initialise stack
USBInit();
// register descriptors
USBRegisterDescriptors(abDescriptors);
// register class request handler
USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData);
// register endpoint handlers
USBHwRegisterEPIntHandler(INT_IN_EP, NULL);
USBHwRegisterEPIntHandler(BULK_IN_EP, BulkIn);
USBHwRegisterEPIntHandler(BULK_OUT_EP, BulkOut);
// register frame handler
USBHwRegisterFrameHandler(USBFrameHandler);
// enable bulk-in interrupts on NAKs
USBHwNakIntEnable(INACK_BI);
// initialise VCOM
VCOM_init();
printf("Starting USB communication\n");
// enable IRQ
NVIC_EnableIRQ(USB_IRQn);
// connect to bus
printf("Connecting to USB bus\n");
USBHwConnect(TRUE);
}
USBSerialStream::USBSerialStream(Stream *echoStream) : m_infifo(512), m_outfifo(512), m_bTransferInProgress(false), m_bDontStartNew(false),
m_bConnected(false)
{
// initialise stack
USBInit();
// register descriptors
USBRegisterDescriptors(abDescriptors);
// register class request handler
USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData);
// register endpoint handlers
USBHwRegisterEPIntHandler(INT_IN_EP, NULL);
USBHwRegisterEPIntHandler(BULK_IN_EP, BulkIn);
USBHwRegisterEPIntHandler(BULK_OUT_EP, BulkOut);
USBHwRegisterDevIntHandler(DevIntHandler);
USBHwRegisterFrameHandler(FrameHandler);
// enable bulk-in interrupts on NAKs
//USBHwNakIntEnable(INACK_BI);
// set up USB interrupt
VICIntSelect &= ~(1<<22); // select IRQ for USB
VICIntEnable |= (1<<22);
(*(&VICVectCntl0+INT_VECT_NUM)) = 0x20 | 22; // choose highest priority ISR slot
(*(&VICVectAddr0+INT_VECT_NUM)) = (int)USBHandlerSerial;
UART_puts("Connecting USB\n\r");
// connect to bus
USBHwConnect(TRUE);
}
void vUSBTask( void *pvParameters )
{
int c;
/* Just to prevent compiler warnings about the unused parameter. */
( void ) pvParameters;
DBG("Initialising USB stack\n");
xRxedChars = xQueueCreate( usbBUFFER_LEN, sizeof( char ) );
xCharsForTx = xQueueCreate( usbBUFFER_LEN, sizeof( char ) );
if( ( xRxedChars == NULL ) || ( xCharsForTx == NULL ) )
{
/* Not enough heap available to create the buffer queues, can't do
anything so just delete ourselves. */
vTaskDelete( NULL );
}
// initialise stack
USBInit();
// register descriptors
USBRegisterDescriptors(abDescriptors);
// register class request handler
USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData);
// register endpoint handlers
USBHwRegisterEPIntHandler(INT_IN_EP, NULL);
USBHwRegisterEPIntHandler(BULK_IN_EP, BulkIn);
USBHwRegisterEPIntHandler(BULK_OUT_EP, BulkOut);
// register frame handler
USBHwRegisterFrameHandler(USBFrameHandler);
// enable bulk-in interrupts on NAKs
USBHwNakIntEnable(INACK_BI);
DBG("Starting USB communication\n");
NVIC_SetPriority( USB_IRQn, configUSB_INTERRUPT_PRIORITY );
NVIC_EnableIRQ( USB_IRQn );
// connect to bus
DBG("Connecting to USB bus\n");
USBHwConnect(TRUE);
// echo any character received (do USB stuff in interrupt)
for( ;; )
{
c = VCOM_getchar();
if (c != EOF)
{
// Echo character back with INCREMENT_ECHO_BY offset, so for example if
// INCREMENT_ECHO_BY is 1 and 'A' is received, 'B' will be echoed back.
VCOM_putchar(c + INCREMENT_ECHO_BY );
}
}
}
/*************************************************************************
main
====
**************************************************************************/
int main(void)
{
int c, i;
IODIR0 |= (1<<10);
// PLL and MAM
HalSysInit();
#ifdef LPC214x
// init DBG
ConsoleInit(60000000 / (16 * BAUD_RATE));
#else
// init DBG
ConsoleInit(72000000 / (16 * BAUD_RATE));
#endif
DBG("Initialising USB stack\n");
// initialise stack
USBInit();
configureADCPort(AD0_3);
// register descriptors
USBRegisterDescriptors(abDescriptors);
// register class request handler
USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData);
// register endpoint handlers
USBHwRegisterEPIntHandler(INT_IN_EP, NULL);
// register frame handler
USBHwRegisterFrameHandler(USBFrameHandler);
// register device event handler
USBHwRegisterDevIntHandler(USBDevIntHandler);
char ch = 'a';
for (i = 0; i < BYTES_PER_ISOC_FRAME; i++) {
inputIsocDataBuffer[i] = ch;
ch = (ch == 'z' ? 'a' : (ch + 1));
}
DBG("Starting USB communication\n");
#ifdef LPC214x
(*(&VICVectCntl0+INT_VECT_NUM)) = 0x20 | 22; // choose highest priority ISR slot
(*(&VICVectAddr0+INT_VECT_NUM)) = (int)USBIntHandler;
#else
VICVectCntl22 = 0x01;
VICVectAddr22 = (int)USBIntHandler;
#endif
// set up USB interrupt
VICIntSelect &= ~(1<<22); // select IRQ for USB
VICIntEnable |= (1<<22);
enableIRQ();
// connect to bus
USBHwConnect(TRUE);
int x = 0;
const int interval = 100000;
// echo any character received (do USB stuff in interrupt)
for(;;) {
x++;
U32 temp = cADC_Result(AD0_3);
if( temp >= 0 && temp <= 1024 )
inputIsocDataBuffer[ADC_INPUT_INDEX] = temp;
inputIsocDataBuffer[BUTTON1_INPUT_INDEX] = ((IOPIN0 & (1<<15)) ? 1 : 0);
inputIsocDataBuffer[BUTTON2_INPUT_INDEX] = ((IOPIN0 & (1<<16)) ? 1 : 0);
if (x == interval) {
IOSET0 = (1<<11);
//turn on led
} else if (x >= (interval*2)) {
IOCLR0 = (1<<11);
//turn off led
x = 0;
}
}
return 0;
}
/*************************************************************************
main
====
**************************************************************************/
int main(void)
{
int x = 0;
const int interval = 200000;
FIO_ENABLE;
vic_disableIRQ();
pllstart_seventytwomhz() ;
// pllstart_sixtymhz() ;
// pllstart_fourtyeightmhz() ;
mam_enable();
info_init();
uart0_init_115200() ;
uart0_putstring("\n***Starting gfe color led test***\n\n");
uart0_putstring("\n***Board is defined as: ");
uart0_putstring( infoquery_gfe_boardtag() );
uart0_putstring(" ***\n");
init_color_led();
RED_LED_OFF;
BLUE_LED_OFF;
GREEN_LED_OFF;
printf_lpc(UART0,"5 FAST flashes...red, blue then green\n");
color_led_flash(5, RED_LED, FLASH_FAST ) ;
RED_LED_OFF;
color_led_flash(5, BLUE_LED, FLASH_FAST ) ;
BLUE_LED_OFF;
color_led_flash(5, GREEN_LED, FLASH_FAST ) ;
GREEN_LED_OFF;
uart0_putstring(" ** END OF TEST ""\n");
printf_lpc(UART0, "Initialising USB stack\n");
// initialize stack
USBInit();
// register descriptors
USBRegisterDescriptors(abDescriptors);
// register class request handler
USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData);
// register endpoint handlers
USBHwRegisterEPIntHandler(INT_IN_EP, NULL);
// register frame handler
USBHwRegisterFrameHandler(USBFrameHandler);
// register device event handler
USBHwRegisterDevIntHandler(USBDevIntHandler);
inputIsocDataBuffer[0] = 0;
printf_lpc(UART0, "Starting USB communication\n");
VICVectPriority22 = 0x01; // 0x0 is highest priority, 0xF is lowest
VICVectAddr22 = (unsigned int)USBIntHandler;
VICAddress = 0x0;
printf_lpc(UART0, "addresses entered\n");
ENABLE_USB_IRQ;
printf_lpc(UART0, "USB IRQ Enabled\n");
vic_enableIRQ();
printf_lpc(UART0, "vic_enable\n");
ENABLE_USB_INT;
printf_lpc(UART0, "USB INT Enabled\n");
//printf_lpc(UART0, "connect to bus\n");
//
// // connect to bus
USBHwConnect(TRUE);
//
for(;;) {
x++;
if (x == interval) {
RED_LED_ON;
} else if (x >= (interval*2)) {
x = 0;
RED_LED_OFF;
}
}
return 0;
}
/*************************************************************************
main
====
**************************************************************************/
int main(void)
{
int c, i;
// PLL and MAM
HalSysInit();
#ifdef LPC214x
// init DBG
ConsoleInit(60000000 / (16 * BAUD_RATE));
#else
// init DBG
ConsoleInit(72000000 / (16 * BAUD_RATE));
#endif
configureADCPort(AD0_3);
DBG("Initialising USB stack\n");
// initialise stack
USBInit();
// register descriptors
USBRegisterDescriptors(abDescriptors);
// register class request handler
USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData);
// register endpoint handlers
USBHwRegisterEPIntHandler(INT_IN_EP, NULL);
// register frame handler
USBHwRegisterFrameHandler(USBFrameHandler);
// register device event handler
USBHwRegisterDevIntHandler(USBDevIntHandler);
USBInitializeUSBDMA(udcaHeadArray);
USBEnableDMAForEndpoint(ISOC_IN_EP);
DBG("Starting USB communication\n");
#ifdef LPC214x
(*(&VICVectCntl0+INT_VECT_NUM)) = 0x20 | 22; // choose highest priority ISR slot
(*(&VICVectAddr0+INT_VECT_NUM)) = (int)USBIntHandler;
#else
VICVectCntl22 = 0x01;
VICVectAddr22 = (int)USBIntHandler;
#endif
// set up USB interrupt
VICIntSelect &= ~(1<<22); // select IRQ for USB
VICIntEnable |= (1<<22);
enableIRQ();
// connect to bus
USBHwConnect(TRUE);
int x = 0;
c = EOF;
//populate source data with all 'B's
for(i = 0; i < ISOC_INPUT_DATA_BUFFER_SIZE; i++ ) {
inputIsocDataBuffer[i] = 'B';
}
int cnt = 0;
const int interval = 100000;
// echo any character received (do USB stuff in interrupt)
for(;;) {
x++;
U32 temp = cADC_Result(AD0_3);
if( temp >= 0 && temp <= 1024 )
currentADCReadValue = temp;
if (x == interval) {
qq++;
IOSET0 = (1<<11);
//turn on led
} else if (x >= (interval*2)) {
IOCLR0 = (1<<11);
//turn off led
x = 0;
}
}
return 0;
}
/*************************************************************************
main
====
**************************************************************************/
int main(void)
{
// USB: Init
// CAS -> Initialization of KbdInputReport to initial values (0,0,0,0,..)
HIDDKbdInputReport_Initialize (&KbdInputReport);
// CAS -> Variable used to simulate the pressing of Letter A (0x04)
int i;
DBG("Initialising USB stack\n");
// CAS -> Variable used to simulate the pressing of Letter A (0x04)
// USBInit()
// USBHwInit() HW Init
// -> Set Pins for USB, AHBClock, ACK generate interrupts
// USBHwRegisterDevIntHandler(HandleUsbReset)
// -> Define un handler (HandleUsbReset).
//
// initialize stack
USBInit();
// register device descriptors
USBRegisterDescriptors(abDescriptors);
// register HID standard request handler
USBRegisterCustomReqHandler(HIDHandleStdReq);
// register class request handler
USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData);
// register endpoint (2?). Interrupt In Endpoint
USBHwRegisterEPIntHandler(INTR_IN_EP, NULL);
// register frame handler
USBHwRegisterFrameHandler(HandleFrame);
DBG("Starting USB communication\n");
// connect to bus
USBHwConnect(TRUE);
//RC5: Init
GPIO_SetDir(0,1<<4,1);
GPIO_SetDir(0,1<<5,1);
GPIO_SetValue(0,1<<5);
GPIO_SetValue(0,1<<4);
RC5_Init();
// main() Loop:
// call USB interrupt handler continuously
// CodeRed - either read mouse, or provide "fake mouse readings"
while (1)
{
for (i=0; i<10; i++) {
// RC5
if (RC5_flag) // wait for RC5 code
{
if((RC5_System==0)&&(RC5_Command==1)){
GPIO_ClearValue(0,1<<4);
for(i=0;i<1000000;i++);
GPIO_SetValue(0,1<<4);
for(i=0;i<1000000;i++);
}
if((RC5_System==0)&&(RC5_Command==5)){
GPIO_ClearValue(0,1<<5);
for(i=0;i<1000000;i++);
GPIO_SetValue(0,1<<5);
for(i=0;i<1000000;i++);
}
RC5_flag = 0;
printf( "RC5 = %d %d\n", RC5_System, RC5_Command);
}
// RC5
USBHwISR();
if (i < 5) {
KbdInputReport.Key_1 = 0x04;
}
else {
KbdInputReport.Key_1 = 0x00;
}
}
}
return 0;
}
/*************************************************************************
main
====
**************************************************************************/
bool USBStart(void)
{
int c;
// initialise stack
USBInit();
// register descriptors
USBRegisterDescriptors(abDescriptors);
// register class request handler
USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData);
// register endpoint handlers
USBHwRegisterEPIntHandler(INT_IN_EP, NULL);
USBHwRegisterEPIntHandler(BULK_IN_EP, BulkIn);
USBHwRegisterEPIntHandler(BULK_OUT_EP, BulkOut);
// register frame handler
USBHwRegisterFrameHandler(USBFrameHandler);
// register device event handler
USBHwRegisterDevIntHandler(USBDevIntHandler);
// initialise VCOM
VCOM_init();
VICVectCntl22 = 0x01;
VICVectAddr22 = (int)USBIntHandler;
// set up USB interrupt
VICIntSelect &= ~(1<<22); // select IRQ for USB
VICIntEnable |= (1<<22);
// connect to bus
USBHwConnect(TRUE);
#if TCM
// echo any character received (do USB stuff in interrupt)
while (1) {
c = VCOM_getchar();
if (c != EOF) {
// show on console
if ((c == 9) || (c == 10) || (c == 13) || ((c >= 32) && (c <= 126))) {
DBG("%c", c);
}
else {
DBG(".");
}
VCOM_putchar(c);
}
}
return 0;
#endif
return true;
}
/*************************************************************************
main
====
**************************************************************************/
int main(void)
{
GO go_entry;
// PLL and MAM
Initialize();
// init DBG
ConsoleInit(CCLK / (16 * BAUD_RATE));
DBG("Initialising USB stack\n");
write_ram_len=0;
read_mem_len=0;
unlocked=0;
bEcho=1;
// initialise stack
USBInit();
// register descriptors
USBRegisterDescriptors(abDescriptors);
// register vendor request handler
USBRegisterRequestHandler(REQTYPE_TYPE_VENDOR, HandleVendorRequest);
// register pre request handler
USBRegisterPreRequestHandler(PreHandleRequest);
DBG("Starting USB communication\n");
// connect to bus
USBHwConnect(TRUE);
start_app = 0;
// call USB interrupt handler continuously
while (1)
{
USBHwISR();
if (start_app == 1)
{
volatile unsigned int count;
// wait some time until response is sent
for (count=0;count<10000;count++) USBHwISR();
// disconnect from bus
USBHwConnect(FALSE);
// wait some ms so that called app might safely re-connect usb
for (count=0;count<300000;count++) count=count;
go_entry = (GO) (start_adr);
go_entry();
}
}
return 0;
}
/*************************************************************************
main
====
**************************************************************************/
int main(void)
{
IODIR0 |= (1<<10);//Debug LED on the olimex 2148 dev board set to output mode
IODIR0 |= (1<<11);//Debug LED on the olimex 2148 dev board set to output mode
// PLL and MAM
HalSysInit();
#ifdef LPC214x
// init DBG
ConsoleInit(60000000 / (16 * BAUD_RATE));
#else
// init DBG
ConsoleInit(72000000 / (16 * BAUD_RATE));
#endif
DBG("Initialising USB stack\n");
// initialise stack
USBInit();
// register descriptors
USBRegisterDescriptors(abDescriptors);
// register class request handler
USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData);
// register endpoint handlers
USBHwRegisterEPIntHandler(INT_IN_EP, NULL);
// register frame handler
USBHwRegisterFrameHandler(USBFrameHandler);
// register device event handler
USBHwRegisterDevIntHandler(USBDevIntHandler);
inputIsocDataBuffer[0] = 0;
USBInitializeUSBDMA(udcaHeadArray);
USBEnableDMAForEndpoint(ISOC_IN_EP);
DBG("Starting USB communication\n");
#ifdef LPC214x
(*(&VICVectCntl0+INT_VECT_NUM)) = 0x20 | 22; // choose highest priority ISR slot
(*(&VICVectAddr0+INT_VECT_NUM)) = (int)USBIntHandler;
#else
VICVectCntl22 = 0x01;
VICVectAddr22 = (int)USBIntHandler;
#endif
// set up USB interrupt
VICIntSelect &= ~(1<<22); // select IRQ for USB
VICIntEnable |= (1<<22);
enableIRQ();
// connect to bus
USBHwConnect(TRUE);
int x = 0;
const int interval = 200000;
// echo any character received (do USB stuff in interrupt)
for(;;) {
x++;
if (x == interval) {
IOSET0 = (1<<11);//turn on led on olimex dev board
} else if (x >= (interval*2)) {
IOCLR0 = (1<<11);//turn off led on olimex dev board
x = 0;
}
}
return 0;
}