Example #1
0
__interrupt VOID UNMI_ISR(VOID)
{
    switch (__even_in_range(SYSUNIV, SYSUNIV_SYSBUSIV))
    {
    case SYSUNIV_NONE:
      __no_operation();
      break;
    case SYSUNIV_NMIIFG:
      __no_operation();
      break;
    case SYSUNIV_OFIFG:
      UCSCTL7 &= ~(DCOFFG+0+0+0); // Clear OSC fault source flags 
      SFRIFG1 &= ~OFIFG;                                // Clear OFIFG flag
      break;
    case SYSUNIV_ACCVIFG:
      __no_operation();
      break;
    case SYSUNIV_SYSBUSIV:
      
      // In the rare event of an internal system bus error - must clear the flag and re-initialize USB. 
      SYSBERRIV = 0;            // Clear flag
      USB_disable();            // Disable USB
      if (USB_connectionInfo() & kUSB_vbusPresent)
        USB_handleVbusOnEvent();
    }
}
Example #2
0
void usb_printf_init(void) {
    SetVCore(3);
    init_clock();
    //Init USB
    USB_init();                 
    //Enable various USB event handling routines
    USB_setEnabledEvents(kUSB_VbusOnEvent + 
                         kUSB_VbusOffEvent + 
                         kUSB_receiveCompletedEvent + 
                         kUSB_dataReceivedEvent + 
                         kUSB_UsbSuspendEvent + 
                         kUSB_UsbResumeEvent +
                         kUSB_UsbResetEvent);
    // See if we're already attached physically to USB, and if so, 
    // connect to it. Normally applications don't invoke the event 
    // handlers, but this is an exception.
    if(USB_connectionInfo() & kUSB_vbusPresent) {
        usb_printf_state = USB_ENABLED;
        USB_handleVbusOnEvent();
    }
}
Example #3
0
/**
 * Configuration de l'USB et de ses Events
 */
void iUSB::config()
    {
    //Ne pas oublier d'avoir setVcore(3) avant
    //initialisation de l'USB
    this->initUSB();

    //Enable various USB event handling routines
    USB_setEnabledEvents(
	    kUSB_VbusOnEvent + kUSB_VbusOffEvent + kUSB_receiveCompletedEvent
		    + kUSB_dataReceivedEvent + kUSB_UsbSuspendEvent
		    + kUSB_UsbResumeEvent + kUSB_UsbResetEvent);

    //See if we're already attached physically to USB, and if so, connect to it
    //Normally applications don't invoke the event handlers, but this is an exception.
    if (USB_connectionInfo() & kUSB_vbusPresent)
	{
	USB_handleVbusOnEvent();
	}

    //desactiver LDO
    USBPWRCTL &= ~(SLDOEN);      // Disable the VUSB LDO and the SLDO
    }
Example #4
0
__interrupt VOID iUsbInterruptHandler(VOID)
{
    BYTE bWakeUp = FALSE;
    //Check if the setup interrupt is pending.
    //We need to check it before other interrupts,
    //to work around that the Setup Int has lower priority then Input Endpoint 0
    if (USBIFG & SETUPIFG)
    {
        bWakeUp = SetupPacketInterruptHandler();  
        USBIFG &= ~SETUPIFG;    // clear the interrupt bit
    }   
    switch (__even_in_range(USBVECINT & 0x3f, USBVECINT_OUTPUT_ENDPOINT7))
    {
    case USBVECINT_NONE:
      break;
    case USBVECINT_PWR_DROP:
      __no_operation();
      break;
    case USBVECINT_PLL_LOCK:
      break;
    case USBVECINT_PLL_SIGNAL:
      break;
    case USBVECINT_PLL_RANGE:
      if (wUsbEventMask & kUSB_clockFaultEvent)
      {
          bWakeUp = USB_handleClockEvent();
      }
      break;
    case USBVECINT_PWR_VBUSOn:
      PWRVBUSonHandler();
      if (wUsbEventMask & kUSB_VbusOnEvent)
      {
          bWakeUp = USB_handleVbusOnEvent();
      }
      break;
    case USBVECINT_PWR_VBUSOff:
      PWRVBUSoffHandler();
      if (wUsbEventMask & kUSB_VbusOffEvent)
      {
          bWakeUp = USB_handleVbusOffEvent();
      }
      break;
    case USBVECINT_USB_TIMESTAMP:
      break;
    case USBVECINT_INPUT_ENDPOINT0:
      IEP0InterruptHandler();
      break;
    case USBVECINT_OUTPUT_ENDPOINT0:
      OEP0InterruptHandler();
      break;
    case USBVECINT_RSTR:
      USB_reset();
      if (wUsbEventMask & kUSB_UsbResetEvent)
      {
          bWakeUp = USB_handleResetEvent();
      }
      break;
    case USBVECINT_SUSR:
      USB_suspend();
      if (wUsbEventMask & kUSB_UsbSuspendEvent)
      {
          bWakeUp = USB_handleSuspendEvent();
      }
      break;
    case USBVECINT_RESR:
      USB_resume();
      if (wUsbEventMask & kUSB_UsbResumeEvent)
      {
          bWakeUp = USB_handleResumeEvent();
      }
      //-- after resume we will wake up! Independ what event handler says.
      bWakeUp = TRUE;
      break;
    case USBVECINT_SETUP_PACKET_RECEIVED:
      // NAK both IEP and OEP enpoints
      tEndPoint0DescriptorBlock.bIEPBCNT = EPBCNT_NAK;
      tEndPoint0DescriptorBlock.bOEPBCNT = EPBCNT_NAK;
      SetupPacketInterruptHandler();
      break;
    case USBVECINT_STPOW_PACKET_RECEIVED:
      break;
    case USBVECINT_INPUT_ENDPOINT1:
      //send saved bytes from buffer...
      bWakeUp = HidToHostFromBuffer(HID0_INTFNUM);
      break;
    case USBVECINT_INPUT_ENDPOINT2:
      break;
    case USBVECINT_INPUT_ENDPOINT3:
      break;
    case USBVECINT_INPUT_ENDPOINT4:
      break;
    case USBVECINT_INPUT_ENDPOINT5:
      break;
    case USBVECINT_INPUT_ENDPOINT6:
      break;
    case USBVECINT_INPUT_ENDPOINT7:
      break;
    case USBVECINT_OUTPUT_ENDPOINT1:
      //call callback function if no receive operation is underway
      if (!HidIsReceiveInProgress(HID0_INTFNUM))
      {
           if (wUsbEventMask & kUSB_dataReceivedEvent)
           {
               bWakeUp = USBHID_handleDataReceived(HID0_INTFNUM); 
           }
      }
      else
      {
           //complete receive opereation - copy data to user buffer 
           bWakeUp = HidToBufferFromHost(HID0_INTFNUM);
      } 
      break;
    case USBVECINT_OUTPUT_ENDPOINT2:
      break;
    case USBVECINT_OUTPUT_ENDPOINT3:
      break;
    case USBVECINT_OUTPUT_ENDPOINT4:
      break;
    case USBVECINT_OUTPUT_ENDPOINT5:
      break;
    case USBVECINT_OUTPUT_ENDPOINT6:
      break;
    case USBVECINT_OUTPUT_ENDPOINT7:
      break;
    default:
      break;
    }
    if (bWakeUp)
    {
    	 __bic_SR_register_on_exit(LPM3_bits);   // Exit LPM0-3
    	 __no_operation();                       // Required for debugger
    }
}
Example #5
0
/*  
 * ======== main ========
 */
VOID main (VOID)
{
    WDTCTL = WDTPW + WDTHOLD;                                   //Stop watchdog timer

    Init_Ports();                                               //Init ports (do first ports because clocks do change ports)
    SetVCore(3);
    Init_Clock();                                               //Init clocks
	
    USB_init();                 //Init USB

    Init_TimerA1();
	
    //Enable various USB event handling routines
    USB_setEnabledEvents(
        kUSB_VbusOnEvent + kUSB_VbusOffEvent + kUSB_receiveCompletedEvent
        + kUSB_dataReceivedEvent + kUSB_UsbSuspendEvent + kUSB_UsbResumeEvent +
        kUSB_UsbResetEvent);

    //See if we're already attached physically to USB, and if so, connect to it
    //Normally applications don't invoke the event handlers, but this is an exception.
    if (USB_connectionInfo() & kUSB_vbusPresent){
        USB_handleVbusOnEvent();
    }

	__enable_interrupt();                           //Enable interrupts globally
    while (1)
    {
        BYTE i;
        //Check the USB state and directly main loop accordingly
        switch (USB_connectionState())
        {
            case ST_USB_DISCONNECTED:
                __bis_SR_register(LPM3_bits + GIE);                                 //Enter LPM3 w/ interrupts enabled
                _NOP();                                                             //For Debugger
                break;

            case ST_USB_CONNECTED_NO_ENUM:
                break;

            case ST_ENUM_ACTIVE:
                __bis_SR_register(LPM0_bits + GIE);                                 //Enter LPM0 (can't do LPM3 when active)
                _NOP();                                                             //For Debugger

                                                                                    //Exit LPM on USB receive and perform a receive
                                                                                    //operation
                if (bCDCDataReceived_event){                                        //Some data is in the buffer; begin receiving a
                                                                                    //command
                    char pieceOfString[MAX_STR_LENGTH] = "";                        //Holds the new addition to the string
                    char outString[MAX_STR_LENGTH] = "";                            //Holds the outgoing string

                                                                                    //Add bytes in USB buffer to theCommand
                    cdcReceiveDataInBuffer((BYTE*)pieceOfString,
                        MAX_STR_LENGTH,
                        CDC0_INTFNUM);                                                         //Get the next piece of the string
                    strcat(wholeString,pieceOfString);
                    cdcSendDataInBackground((BYTE*)pieceOfString,
                        strlen(pieceOfString),CDC0_INTFNUM,0);                      //Echoes back the characters received (needed
                                                                                    //for Hyperterm)

                    if (retInString(wholeString)){                                  //Has the user pressed return yet?
                        if (!(strcmp(wholeString, "LED ON"))){                      //Compare to string #1, and respond
                            TA1CTL &= ~MC_1;                                        //Turn off Timer
                            P1OUT |= BIT0;                                          //Turn on LED P1.0
                            strcpy(outString,"\r\nLED is ON\r\n\r\n");              //Prepare the outgoing string
                            cdcSendDataInBackground((BYTE*)outString,
                                strlen(outString),CDC0_INTFNUM,0);                  //Send the response over USB
                        } else if (!(strcmp(wholeString, "LED OFF"))){              //Compare to string #2, and respond
                            TA1CTL &= ~MC_1;                                        //Turn off Timer
                            P1OUT &= ~BIT0;                                         //Turn off LED P1.0
                            strcpy(outString,"\r\nLED is OFF\r\n\r\n");             //Prepare the outgoing string
                            cdcSendDataInBackground((BYTE*)outString,
                                strlen(outString),CDC0_INTFNUM,0);                  //Send the response over USB
                        } else if (!(strcmp(wholeString,
                                         "LED TOGGLE - SLOW"))){                    //Compare to string #3, and respond
                            TA1CTL &= ~MC_1;                                        //Turn off Timer
                            TA1CCR0 = SlowToggle_Period;                            //Set Timer Period for slow LED toggle
                            TA1CTL |= MC_1;                                         //Start Timer
                            strcpy(outString,
                                "\r\nLED is toggling slowly\r\n\r\n");              //Prepare the outgoing string
                            cdcSendDataInBackground((BYTE*)outString,
                                strlen(outString),CDC0_INTFNUM,0);                  //Send the response over USB
                        } else if (!(strcmp(wholeString,
                                         "LED TOGGLE - FAST"))){                    //Compare to string #4, and respond
                            TA1CTL &= ~MC_1;                                        //Turn off Timer
                            TA1CCR0 = FastToggle_Period;                            //Set Timer Period for fast LED toggle
                            TA1CTL |= MC_1;
                            strcpy(outString,"\r\nLED is toggling fast\r\n\r\n");   //Prepare the outgoing string
                            cdcSendDataInBackground((BYTE*)outString,
                                strlen(outString),CDC0_INTFNUM,0);                  //Send the response over USB
                        } else {                                                    //Handle other
                            strcpy(outString,"\r\nNo such command!\r\n\r\n");       //Prepare the outgoing string
                            cdcSendDataInBackground((BYTE*)outString,
                                strlen(outString),CDC0_INTFNUM,0);                  //Send the response over USB
                        }
                        for (i = 0; i < MAX_STR_LENGTH; i++){                       //Clear the string in preparation for the next
                                                                                    //one
                            wholeString[i] = 0x00;
                        }
                    }
                    bCDCDataReceived_event = FALSE;
                }
                break;

            case ST_ENUM_SUSPENDED:
                P1OUT &= ~BIT0;                                                     //When suspended, turn off LED
                __bis_SR_register(LPM3_bits + GIE);                                 //Enter LPM3 w/ interrupts
                _NOP();
                break;

            case ST_ENUM_IN_PROGRESS:
                break;

            case ST_NOENUM_SUSPENDED:
                P1OUT &= ~BIT0;
                __bis_SR_register(LPM3_bits + GIE);
                _NOP();
                break;

            case ST_ERROR:
                _NOP();
                break;

            default:;
        }
    }  //while(1)
} //main()
Example #6
0
/*----------------------------------------------------------------------------+
| Main Routine                                                                |
+----------------------------------------------------------------------------*/
VOID main(VOID)
{
    WDTCTL = WDTPW + WDTHOLD;	    // Stop watchdog timer
    Init_StartUp();
    
    USB_init();
    
    USB_setEnabledEvents(kUSB_VbusOnEvent+kUSB_VbusOffEvent+kUSB_receiveCompletedEvent
                          +kUSB_dataReceivedEvent+kUSB_UsbSuspendEvent+kUSB_UsbResumeEvent+kUSB_UsbResetEvent);
    
    // Check if we're already physically attached to USB, and if so, connect to it
    // This is the same function that gets called automatically when VBUS gets attached.  
    if (USB_connectionInfo() & kUSB_vbusPresent)
      USB_handleVbusOnEvent();
      //PWRVBUSonHandler();
                 
    while(1)
    {
        switch(USB_connectionState())
        {
           case ST_USB_DISCONNECTED:
                 __bis_SR_register(LPM3_bits + GIE); 	  // Enter LPM3 w/interrupt
                break;
                
           case ST_USB_CONNECTED_NO_ENUM:
                break;
                
           case ST_ENUM_ACTIVE:
                if(!bCommandBeingProcessed)                  // If no command is being processed, then make sure there's a rcv operation 
                {                                            // open to receive the start of the "packet"
                  if(!(USBCDC_intfStatus(0,&x,&y) & kUSBCDC_waitingForReceive))      // Only open it if we haven't already done so
                    if(USBCDC_receiveData(buffer,1,0) == kUSBCDC_busNotAvailable) // Start a receive operation for a single byte -- the "size" byte of the "packet"
                    {
                      USBCDC_abortReceive(&x,0);                                     // Abort receive
                      break;                                 // If bus is no longer available, escape out of the loop
                    }
                }
                
                __bis_SR_register(LPM0_bits + GIE);          // Wait in LPM0 until a receive operation has completed
                //__bis_SR_register(LPM0_bits + GIE);
                if(bDataReceiveCompleted_event)
                {
                  bDataReceiveCompleted_event = FALSE;
                  if(!bCommandBeingProcessed)                // This means that the incoming byte is the start of the "packet" -- the "size" byte
                  {
                    if ((buffer[0]>=0x31) &&  (buffer[0]<= 0x39))
                    {
                        size = buffer[0]-0x30;                 // It's in ASCII, so convert it to a number
                        
                        if(USBCDC_receiveData(buffer,size,0) == kUSBCDC_busNotAvailable)  // And then open a rcv operation for that size
                        {
                          USBCDC_abortReceive(&x,0);                                      // Abort receive
                          break;                                 // If bus is no longer available, escape out of the loop
                        }
                        bCommandBeingProcessed = TRUE;           // Now we're waiting for the "data" part of the "packet"
                    }
                    
                    else 
                    {
                       strcpy(outString,"\r\nEnter a valid number between 1 and 9\r\n\r\n");     // Prepare the outgoing string
                       if(cdcSendDataInBackground((BYTE*)outString,strlen(outString),0,0)) // Send the response over USB
                       {
                          USBCDC_abortSend(&x,0);                                         // Operation may still be open; cancel it
                          break;                                                          // If the send fails, escape the main loop
                        }
                        bCommandBeingProcessed = FALSE;                                   // Now we're back to waiting for the "size" byte
                    }
                  }
                  else                                       // This means that the incoming data is the "data" part of the "packet"
                  {
                    strcpy(outString,"\r\nI received your packet with size of ");     // Prepare the outgoing string
                    buffer[bufferLen-1]= 0;
                    c[0] = (char)(size+'0');   
                    c[1] = 0;
                    outString[64] = 0;                                      // Convert the size back to ASCII
                    strcat(outString,c);
                    strcat(outString," bytes.\r\n\r\n");                              
                    if(cdcSendDataInBackground((BYTE*)outString,strlen(outString),0,0)) // Send the response over USB
                    {
                      USBCDC_abortSend(&x,0);                                         // Operation may still be open; cancel it
                      break;                                                          // If the send fails, escape the main loop
                    }
                    bCommandBeingProcessed = FALSE;                                   // Now we're back to waiting for the "size" byte
                  }
                }
                break;
                
           case ST_ENUM_SUSPENDED:
                __bis_SR_register(LPM3_bits + GIE); 	// Enter LPM3 w/interrupt
                break;
           
           case ST_ENUM_IN_PROGRESS:
                break;
           
           case ST_NOENUM_SUSPENDED:
                __bis_SR_register(LPM3_bits + GIE);  
                _NOP();
                break;
          
           case ST_ERROR:
                _NOP();
                break;
                
           default:;
        }
    }  // while(1) 
} //main()
Example #7
0
VOID main(VOID) 
{
    WDTCTL = WDTPW + WDTHOLD;	    // Stop watchdog timer
    
    Init_StartUp();                 //initialize device
    USB_init();
    
    USB_setEnabledEvents(USBEVIE);
    
    // See if we're already attached physically to USB, and if so, connect to it
    // Normally applications don't invoke the event handlers, but this is an exception.  
    if (USB_connectionInfo() & kUSB_vbusPresent)
      USB_handleVbusOnEvent();
    
    
    while(1)
    {
        switch(USB_connectionState())
        {
           case ST_USB_DISCONNECTED:
                 __bis_SR_register(LPM3_bits + GIE); 	  // Enter LPM3 w/interrupt
                _NOP();
                break;
                
           case ST_USB_CONNECTED_NO_ENUM:
                break;
                
           case ST_ENUM_ACTIVE:
                __bis_SR_register(LPM0_bits + GIE); 	  // Enter LPM0 until an event occurs.  


                // This flag would have been set by the handleDataReceived event; this event is only enabled when waiting
                // for 'press any key'
                if(bCDCDataReceived_event) 
                {
                  bCDCDataReceived_event = FALSE;            

                  // Change the event flags, in preparation for receiving 1K data
                  USBEVIE &= ~kUSB_dataReceivedEvent;      // No more data-received.  We only used this for 'press any key'
                  USBEVIE |= kUSB_receiveCompletedEvent;   // But enable receive-completed; we want to be prompted when 1K data has been received
                  USB_setEnabledEvents(USBEVIE);
                  USBCDC_rejectData(0);                    // We don't care what char the key-press was

                  // Prompt user for 1K data
                  strcpy(outString,"I'm ready to receive 1K of data.\r\n");           // Prepare the outgoing string
                  
                  if(cdcSendDataWaitTilDone((BYTE*)outString,strlen(outString),0,0)) // Send it over USB
                  {
                    USBCDC_abortSend(&x,0);                                           // It failed for some reason; abort and leave the main loop
                    break;
                  }
                 
                  // Set up rcv operation for 1K data
                  if(USBCDC_receiveData(dataBuff,1024,0) == kUSBCDC_busNotAvailable) //first USBCDC_receiveData
                  {
                    USBCDC_abortReceive(&x,0);                                       // It failed because of surprise removal or suspended by host; 
                    break;                                                           // abort and leave the main loop
                  }                  
                }
                
                // This flag would have been set by the handleReceiveCompleted event; this event is only enabled  
                // while receiving 1K data, and signals that all 1K has been received
                if(bDataReceiveCompleted_event) 
                {
                  bDataReceiveCompleted_event = FALSE;
                  strcpy(outString,"Thanks for the data.\r\n");                     // Prepare the outgoing string
                  if(cdcSendDataInBackground((BYTE*)outString,strlen(outString),0,0)) //Send the response over USB
                  {
                    USBCDC_abortSend(&x,0);                                         // It failed for some reason; abort and leave the main loop
                    break;
                  }
                  
                  // Change the event flags, in preparation for 'press any key'
                  USBEVIE &= ~kUSB_receiveCompletedEvent;  // No more receive-completed.  
                  USBEVIE |= kUSB_dataReceivedEvent;       // This will tell us that data -- any data -- has arrived (i.e., a key-press)
                  USB_setEnabledEvents(USBEVIE);                
                } 
                    
                break;
                
           case ST_ENUM_SUSPENDED:
                __bis_SR_register(LPM3_bits + GIE); 	        // Enter LPM3 w/ interrupts
                _NOP();
                break;
                
           case ST_ENUM_IN_PROGRESS:
                break;
                
          case ST_NOENUM_SUSPENDED:
                __bis_SR_register(LPM3_bits + GIE);  
                _NOP();
                break;
                
           case ST_ERROR:
                _NOP();
                break;
                
           default:;
        } 
    
    }  // while(1) 
} //main()
Example #8
0
/*----------------------------------------------------------------------------+
| Main Routine                                                                |
+----------------------------------------------------------------------------*/
VOID main(VOID)
{
    WDTCTL = WDTPW + WDTHOLD;	    // Stop watchdog timer
    
    Init_StartUp();
    USB_init();
    USB_setEnabledEvents(kUSB_VbusOnEvent + kUSB_VbusOffEvent + kUSB_UsbSuspendEvent + kUSB_UsbResumeEvent + kUSB_dataReceivedEvent);
   
    // Check if we're already physically attached to USB, and if so, connect to it
    // This is the same function that gets called automatically when VBUS gets attached.  
    if (USB_connectionInfo() & kUSB_vbusPresent)
      USB_handleVbusOnEvent();
              
    // Pre-fill the buffers with visible ASCII characters (0x21 to 0x7E)

    for(x=0;x<BUF_SIZE;x++)
    {
      dataBuf[x] = y++;
      if(y>0x7E)
        y = 0x21;
    }
    
    
    while(1)
    {
        switch(USB_connectionState())
        {
           case ST_USB_DISCONNECTED:
                 __bis_SR_register(LPM3_bits + GIE); 	  // Enter LPM3 w/interrupt
                break;
                
           case ST_USB_CONNECTED_NO_ENUM:
                break;
                
           case ST_ENUM_ACTIVE:
                if(!bHIDDataReceived_event)                          // Do this until a key is pressed
                {
                  strcpy(outString,"Press any key.\r");                             // Prepare the outgoing string
                  if(hidSendDataWaitTilDone((BYTE*)outString,strlen(outString),0,0))  // Send it; no timeout
                  {                      
                    USBHID_abortSend(&x,0);               // Operation may still be open; cancel it
                    break;                                
                  }
                }
                else
                {
                 bHIDDataReceived_event = FALSE;
                  USBHID_rejectData(0);
                  for(rounds=0;rounds<300;rounds++)
                  {
                    if(hidSendDataWaitTilDone(dataBuf,BUF_SIZE,0,0))     // Send all of RAM
                    {
                      USBHID_abortSend(&x,0);               // Operation probably still open; cancel it
                      break;
                    }
                  }
                  strcpy(outString,"\r\n\r\n\r\nThe test is completed.\r\n");       // Prepare the outgoing string
                  if(hidSendDataWaitTilDone((BYTE*)outString,strlen(outString),0,0))  // Send it; no timeout
                  {
                    USBHID_abortSend(&x,0);                 // Operation may still be open; cancel it
                    break;                                 
                  }
                }
                break;
                
           case ST_ENUM_SUSPENDED:
                __bis_SR_register(LPM3_bits + GIE); 	 // Enter LPM3 w/interrupt
                break;
                
           case ST_ENUM_IN_PROGRESS:
                break;
                
           case ST_NOENUM_SUSPENDED:
                __bis_SR_register(LPM3_bits + GIE);                
                break;                
                
           case ST_ERROR:
                _NOP();
                break;
                
           default:;
        }
    }  // while(1) 
} //main()
Example #9
0
/*----------------------------------------------------------------------------+
| Main Routine                                                                |
+----------------------------------------------------------------------------*/
VOID main(VOID)
{
    BYTE y;
    WDTCTL = WDTPW + WDTHOLD;	    // Stop watchdog timer
    
    Init_StartUp();
    USB_init();
 
    USB_setEnabledEvents(kUSB_VbusOnEvent+kUSB_VbusOffEvent+kUSB_receiveCompletedEvent
                          +kUSB_dataReceivedEvent+kUSB_UsbSuspendEvent+kUSB_UsbResumeEvent+kUSB_UsbResetEvent);
    
    // Check if we're already physically attached to USB, and if so, connect to it
    // This is the same function that gets called automatically when VBUS gets attached.  
    if (USB_connectionInfo() & kUSB_vbusPresent)
      USB_handleVbusOnEvent();

    // Pre-fill the buffers with visible ASCII characters (0x21 to 0x7E)
    y=0x21;
    for(w=0;w<MEGA_DATA_LENGTH;w++)
    {
      bufferX[w] = y;
      bufferY[w] = y++;
      if(y>0x7E)
        y = 0x21;
    }
    
                 
    while(1)
    {
        switch(USB_connectionState())
        {
           case ST_USB_DISCONNECTED:
                 __bis_SR_register(LPM3_bits + GIE); 	  // Enter LPM3 w/interrupt
                break;
                
           case ST_USB_CONNECTED_NO_ENUM:
                break;
                
           case ST_ENUM_ACTIVE:
                if(!bCDCDataReceived_event)                         // Do this until a key is pressed
                {
                  strcpy(pakOutString,"Press any key.\r");                                 // Prepare the outgoing string
                  if(cdcSendDataInBackground((BYTE*)pakOutString,strlen(pakOutString),0,0))   // Send it
                  {
                    USBCDC_abortSend(&w,0);              // Operation probably still open; cancel it
                    break;                               // The break isn't really necessary since it'll go to the end of the loop anyway, but it's shown for completeness
                  }
                }
                else
                {
                  if(cdcSendDataInBackground((BYTE*)bufferX,MEGA_DATA_LENGTH,0,0))
                  {
                    bCDCDataReceived_event = FALSE;
                    USBCDC_abortSend(&w,0);              // Operation probably still open; cancel it
                    break;
                  }
                  // Between these functions, don't modify bufferX.  However, bufferY can be modified.  
                  if(cdcSendDataInBackground((BYTE*)bufferY,MEGA_DATA_LENGTH,0,0))
                  {
                    bCDCDataReceived_event = FALSE;
                    USBCDC_abortSend(&w,0);              // Operation probably still open; cancel it
                    break;
                  }
                  // Until the next call to sendData_inBackground(), don't modify bufferY.  However, bufferX can be modified.  
                  
                  if(rounds++>=500)
                  {
                    strcpy(outString,"\r\n\r\nThe test is completed.\r\n\r\n");                  // Prepare the outgoing string
                    if(cdcSendDataInBackground((BYTE*)outString,strlen(outString),0,0))  // Send it
                    {
                      USBCDC_abortSend(&w,0);            // Operation may still be open; cancel it
                      break;
                    }
                    bCDCDataReceived_event= FALSE;
                    rounds = 0;
                    USBCDC_rejectData(0);                // Reject data from previous keypress, in preparation for another one
                  }                                      // It's been in the USB buffer all this time...
                }
                break;
                
           case ST_ENUM_SUSPENDED:
                __bis_SR_register(LPM3_bits + GIE); 	// Enter LPM3 w/interrupt
                break;
                
          	case ST_ENUM_IN_PROGRESS:
                break;
           
           case ST_NOENUM_SUSPENDED:
                __bis_SR_register(LPM3_bits + GIE);  
                _NOP();
                break;
                
           case ST_ERROR:
                _NOP();
                break;
                
           default:;
        }
    }  // while(1) 
} //main()