Exemple #1
0
int main() {
  log_init();

  // If bootloader mode not requested, go immediately to app.
  if (!ShouldEnterBootloader()) {
    OscCalibrateCached();
    log_printf("Running app...");
    __asm__("goto __APP_RESET");
  }

  // We need to enter bootloader mode, wait for the boot pin to be released.
  while (!led_read());

  // Now we can start!
  led_init();
#ifdef SIGNAL_AFTER_BAD_RESET
  if (RCON & 0b1100001001000000) {
    SignalRcon();
  }
#endif

  log_printf("Hello from Bootloader!!!");
  if (IsPin1Grounded()) {
    log_printf("Erasing config.");
    EraseConfig();
  }
  OscCalibrateCached();
  Blink(5);
  USBInitialize();

  while (1) {
    // Wait for connection
    while (!(USBGetDeviceState() == CONFIGURED_STATE
      && CDCIsDtePresent())) USBTasks();

    log_printf("Connected!");
    BootProtocolInit();

    while (USBGetDeviceState() == CONFIGURED_STATE && CDCIsDtePresent()) {
      static char in_buf[64];
      USBTasks();

      BYTE size = getsUSBUSART(in_buf, sizeof(in_buf));
      if (!BootProtocolProcess(in_buf, size)) {
        log_printf("Protocol error. Will detach / re-attach.");
        USBSoftDetach();
        __delay_ms(2000);
        USBDeviceAttach();
        break;
      }
      BootProtocolTasks();
    }
    log_printf("Disconnected!");
  }
  return 0;
}
Exemple #2
0
// *--------------------------------------------------------------------------------*
int main(){
	UINT16 Count=0;
	
    mJTAGPortEnable(0);							// JTAG des-habilitado
	SYSTEMConfigPerformance(GetSystemClock()); 	// Activa pre-cache.-
	
	LED1_OUTPUT();
	LED2_OUTPUT();
	INTEnableSystemMultiVectoredInt();
	deviceAttached = FALSE;
    //Initialize the stack
    USBInitialize(0);
    
	while(1){
		//USB stack process function
        USBTasks();
		if(++Count==0){
			LED1_TOGGLE();
		}
        //if thumbdrive is plugged in
        if(USBHostMSDSCSIMediaDetect()){
            deviceAttached = TRUE;
            LED1_OFF();
            //now a device is attached
            //See if the device is attached and in the right format
            if(FSInit()){
                //Opening a file in mode "w" will create the file if it doesn't
                //  exist.  If the file does exist it will delete the old file
                //  and create a new one that is blank.
                myFile = FSfopen("test.txt","w");

                //Write some data to the new file.
                FSfwrite("This is a test.",1,15,myFile);                

                //Always make sure to close the file so that the data gets
                //  written to the drive.
                FSfclose(myFile);

                //Just sit here until the device is removed.
                while(deviceAttached == TRUE){
                    USBTasks();
                    if(++Count==0){
						LED2_TOGGLE();
					}
                }
                LED2_OFF();
            }
        }
	}
}
Exemple #3
0
void ConnectionTasks() {
  int i;
  USBTasks();
  for (i = 0; i < CHANNEL_TYPE_MAX; ++i) {
    factories[i]->tasks();
  }
}
Exemple #4
0
BOOL BootloaderConnTasks() {
  int role = USBTasks();
  ConnADBTasks();

  return !role  // device mode
      || USBHostAndroidIsInterfaceAttached(ANDROID_INTERFACE_ADB)
      || unknown_device_attached;
}
/******************************************************************************
 * Function:        void main(void)
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        Main program entry point.
 *
 * Note:            None
 *****************************************************************************/
void main(void)
{
    InitializeSystem();
    while(1)
    {
        USBTasks();         // USB Tasks
        ProcessIO();        // See user\user.c & .h
    }//end while
}//end main
Exemple #6
0
void bootloader(void)
{
	FSFILE* file;

	USBInitialize(0);

	if (!FSInit())
	{
		// File system failed - pretty much DISKmount didn't work
		AT45D_FormatFS();
		if (!FSInit())
		{
			error(ERR_FS_INIT);
		}
	}

	while (1)
	{
		USBTasks();
		BlinkBlueLED();

		// User Application USB tasks
		if ((USBDeviceState < CONFIGURED_STATE) || (USBSuspendControl == 1))
		{
			// do nothing
		}
		else
		{
			BlinkGreenLED();
			MSDTasks();
		}
		if (_T1IF)
		{
			_T1IF = 0;

			// check for MSD activity...
			if (MDD_AT45D_Write_Activity)
			{
				MDD_AT45D_Write_Activity = 0;
			}
			else
			{
				file = FSfopen("image.hex", "r");
				if (file != NULL)
				{
					file_flash(file);
					FSfclose(file);
					FSremove("image.hex");
					//AT45D_FormatFS();
					return;
				}
			}
		}
	}
}
Exemple #7
0
/**
 * Main function
 * Main program entry point.
 *
 */
void main(void)
{
    InitializeSystem();

    tickInit();

    while(1)
    {
        USBTasks();
        BlinkUSBStatus();
        if (!((usb_device_state < CONFIGURED_STATE)||(UCONbits.SUSPND==1)))
           ProcessIO();  // See user\user.c & .h
    }
}
Exemple #8
0
// Calibrate the oscillar according to the SOF clock coming from a USB host.
// This function will first block until a USB connection has been established.
// Then it will wait for 32 SOF's for the tuning process (will hang if they do
// not arrive!). Then, if will disconnect from the USB bus and wait 2 seconds.
// Upon exit, the _TUN register will hold the correct value.
static void OscCalibrate() {
  int i;

  led_init();
  USBInitialize();

  // Start timer2/3 as 32-bit, system clock (16MHz).
  T2CON = 0x0008;
  PR2 = PR3 = 0xFFFF;
  T2CON = 0x8008;

  // Wait for a USB connection. Blink meanwhile.
  int led_counter = 0;
  while (USBGetDeviceState() != POWERED_STATE) {
    USBTasks();
    if ((led_counter++ & 0x3FFF) == 0) led_toggle();
  }
  led_off();

  log_printf("Connected to host. Starting calibration.");

  // Start from 0 (redundant, but better be explicit).
  _TUN = 0;

  for (i = 0; i < 32; ++i) {
    uint32_t duration;
    // Repeat for sanity: if for some reason the SOF is too long or too short,
    // ignore it.
    do {
      duration = MeasureSOF();
    } while (duration < 15000 || duration > 17000);

    if (duration < 16000 && _TUN != 31) {
      // We're running too slow.
      _TUN++;
    } else if (duration > 16000 && _TUN != 32) {
      // We're running too fast.
      _TUN--;
    }
  }
  log_printf("Duration: %lu, TUN=%d", MeasureSOF(), _TUN);

  // Undo side-effects.
  T2CON = 0x0000;

  // Detach, wait.
  USBShutdown();
  __delay_ms(2000);
}
Exemple #9
0
/******************************************************************************
 * Function:        void Main(void)
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        Main program entry point.
 *
 * Note:            None
 *****************************************************************************/
void Main(void)
{   
	//NOTE: The c018.o file is not included in the linker script for this project.
	//The C initialization code in the c018.c (comes with C18 compiler in the src directory)
	//file is instead modified and included here manually.  This is done so as to provide
	//a more convenient entry method into the bootloader firmware.  Ordinarily the _entry_scn
	//program code section starts at 0x00 and is created by the code of c018.o.  However,
	//the linker will not work if there is more than one section of code trying to occupy 0x00.
	//Therefore, must not use the c018.o code, must instead manually include the useful code
	//here instead.

    // Initialize the C stack pointer, and other compiler managed items as normally done in the c018.c file.
	_asm
    lfsr 1, _stack
    lfsr 2, _stack
    clrf TBLPTRU, 0 
	_endasm
	// End of the important parts of the C initializer.  This bootloader firmware does not use
	// any C initialized user variables (idata memory sections).  Therefore, the above is all
	// the initialization that is required.


    InitializeSystem();		//Some USB, I/O pins, and other initialization

    while(1)
    {
		ClrWdt();		
	    USBTasks();		        // Need to call USBTasks() periodically
	    						// it handles SETUP packets needed for enumeration

		BlinkUSBStatus();		//Blink the LEDs based on current USB state
		
	    if((usb_device_state == CONFIGURED_STATE) && (UCONbits.SUSPND != 1))
	    {
 	       ProcessIO();   // This is where all the actual bootloader related data transfer/self programming takes place
 	    }				  // see ProcessIO() function in the Boot87J50Family.c file.
    }//end while    
    
    
    
}//end main
int main (void)
{

    #if defined (__C30__) || defined __XC16__
        #if defined( __PIC24FJ256GB110__ ) || defined(__PIC24FJ256GB210__)
            // Configure U2RX - put on pin 49 (RP10)
            RPINR19bits.U2RXR = 10;
            // Configure U2TX - put on pin 50 (RP17)
            RPOR8bits.RP17R = 5;

            // Configure SPI2 Data In - put on pin 11 (RP26)
            RPINR22bits.SDI2R = 26;

            // Configure SPI2 Clock Out - put on pin 10 (RP21)
            RPOR10bits.RP21R = 11;

            // Configure SPI2 Data Out - put on pin 12 (RP19)
            RPOR9bits.RP19R = 10;
            OSCCON = 0x3302;    // Enable secondary oscillator
            CLKDIV = 0x0000;    // Set PLL prescaler (1:1)
        #elif defined(__PIC24FJ64GB004__)
            //On the PIC24FJ64GB004 Family of USB microcontrollers, the PLL will not power up and be enabled
            //by default, even if a PLL enabled oscillator configuration is selected (such as HS+PLL).
            //This allows the device to power up at a lower initial operating frequency, which can be
            //advantageous when powered from a source which is not gauranteed to be adequate for 32MHz
            //operation.  On these devices, user firmware needs to manually set the CLKDIV<PLLEN> bit to
            //power up the PLL.
            {
                unsigned int pll_startup_counter = 600;
                CLKDIVbits.PLLEN = 1;
                while(pll_startup_counter--);
            }
            
            //Device switches over automatically to PLL output after PLL is locked and ready.
        #elif defined(__PIC24FJ256DA210__)
            //TX RF3 RP16
            //RX RD0 RP11
            // Configure U2RX - put on RP11
            RPINR19bits.U2RXR = 11;
            // Configure U2TX - put on RP16
            RPOR8bits.RP16R = 5;
        #endif

    #elif defined(__PIC32MX__)
        {
            int  value;

            value = SYSTEMConfigWaitStatesAndPB( GetSystemClock() );

            // Enable the cache for the best performance
            CheKseg0CacheOn();

            INTEnableSystemMultiVectoredInt();

            value = OSCCON;
            while (!(value & 0x00000020))
            {
                value = OSCCON;    // Wait for PLL lock to stabilize
            }
        }

        AD1PCFG = 0xFFFF;   // Set analog pins to digital.
        TRISF   = 0x00;
    #else
        #error Cannot initialize.
    #endif

    UART2Init();

    UART2PrintString( "\r\n\r\nUSB Embedded Host Simple Full Sheet Printer Demo\r\n" );

    // Initialize USB Embedded Host
    USBInitialize(0);

    // Turn on the A/D converter to monitor Vbus.
    InitializeVbusMonitor();


    while(1)
    {
        MonitorVBUS();
        USBTasks();

        if (status.printerAttached)
        {
            if(status.printerStatusDone == 0)
            {
                if(status.printerStatusSent == 0)
                {
                    if(USBHostPrinterGetStatus( printerInfo.deviceAddress, &status.printer ) == USB_SUCCESS)
                    {
                        status.printerStatusSent = 1;
                    }
                }
            } 
            else
            {

                if(status.printer != 0x18)
                {
                    //if there was an error in the printer status then setup to 
                    //  check the status again
                    status.printerStatusSent = 0;
                    status.printerStatusDone = 0;
                }
                else
                {
    
                    if (!status.pagePrinted)
                    {
                        status.pagePrinted = 1;
        
                        UART2PrintString( "Printing to full sheet printer...\r\n" );
        
                        // Initialize
                        USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_JOB_START, USB_NULL, 0, 0 );
        
                        if (!printerInfo.support.supportFlags.supportsVectorGraphics)
                        {
                            // In the demo's initial configuration, this section executes for the HP Deskjet 460.
        
                            UART2PrintString( "Vector graphics are not supported.\r\n" );
        
                            imageInfo.resolution    = 75;
                            imageInfo.scale         = 1.0;
                            imageInfo.positionX     = (PRINTER_PAGE_PORTRAIT_WIDTH - 0x120)/2;
                            imageInfo.positionY     = 100;
                            #if defined( __C30__ ) || defined __XC16__
                                PrintImageFullSheet( (BYTE __prog__ *)(logoMCHP.address), &imageInfo );
                            #elif defined( __PIC32MX__ )
                                PrintImageFullSheet( (const BYTE *)(logoMCHP.address), &imageInfo );
                            #endif
        
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_FONT_NAME, USB_NULL, USB_PRINTER_FONT_COURIER, 0 );
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_FONT_SIZE, USB_NULL, (DWORD)24, 0 );
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_FONT_BOLD, USB_NULL, 0, 0 );
        
                            WriteLine( 200, 325, &(businessCard[0][0]) );
        
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_FONT_MEDIUM, USB_NULL, 0, 0 );
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_FONT_SIZE, USB_NULL, (DWORD)20, 0 );
        
                            WriteLine( 200, 350, &(businessCard[1][0]) );
                            WriteLine( 200, 375, &(businessCard[2][0]) );
                            WriteLine( 200, 400, &(businessCard[3][0]) );
                            WriteLine( 200, 425, &(businessCard[4][0]) );
                            WriteLine( 200, 450, &(businessCard[5][0]) );
                            WriteLine( 200, 475, &(businessCard[6][0]) );
                            WriteLine( 200, 500, &(businessCard[7][0]) );
        
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_FONT_NAME, USB_NULL, USB_PRINTER_FONT_TIMES_NEW_ROMAN, 0 );
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_FONT_SIZE, USB_NULL, (DWORD)18, 0 );
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_FONT_BOLD, USB_NULL, 0, 0 );
        
                            WriteLine( 50, PRINTER_PAGE_PORTRAIT_HEIGHT - 145, &(adddressMicrochip[0][0]) );
        
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_FONT_MEDIUM, USB_NULL, 0, 0 );
        
                            WriteLine( 50, PRINTER_PAGE_PORTRAIT_HEIGHT - 120, &(adddressMicrochip[1][0]) );
                            WriteLine( 50, PRINTER_PAGE_PORTRAIT_HEIGHT - 95, &(adddressMicrochip[2][0]) );
                            WriteLine( 50, PRINTER_PAGE_PORTRAIT_HEIGHT - 70, &(adddressMicrochip[3][0]) );
                        }
                        else
                        {
                            // In the demo's initial configuration, this section executes for the Lexmark E250dn.
        
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_ORIENTATION_LANDSCAPE, USB_NULL, 0, 0 );

                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_GRAPHICS_LINE_WIDTH, USB_NULL, PRINTER_LINE_WIDTH_THICK, 0 );
        
                            params.sBevel.xL    = 50;     // X-axis position of the left side of the bevel.
                            params.sBevel.yT    = 50;     // Y-axis position of the top of the bevel.
                            params.sBevel.xR    = PRINTER_PAGE_LANDSCAPE_WIDTH  - 50;     // X-axis position of the right side of the bevel.
                            params.sBevel.yB    = PRINTER_PAGE_LANDSCAPE_HEIGHT - 50;     // Y-axis position of the bottom of the bevel.
                            params.sBevel.r     = 20;      // The radius of the cicle that defines the rounded corner
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_GRAPHICS_BEVEL, USB_DATA_POINTER_RAM(&params), sizeof(params.sBevel), 0 );
        
                            imageInfo.resolution    = 75;
                            imageInfo.scale         = 1.0;
                            imageInfo.positionX     = 100;
                            imageInfo.positionY     = 100;
                            #if defined( __C30__ ) || defined __XC16__
                                PrintImageFullSheet( (BYTE __prog__ *)(logoMCHP.address), &imageInfo );
                            #elif defined( __PIC32MX__ )
                                PrintImageFullSheet( (const BYTE *)(logoMCHP.address), &imageInfo );
                            #endif
        
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_FONT_NAME, USB_NULL, USB_PRINTER_FONT_HELVETICA, 0 );
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_FONT_SIZE, USB_NULL, (DWORD)18, 0 );
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_FONT_BOLD, USB_NULL, 0, 0 );
        
                            WriteLine( 100, PRINTER_PAGE_LANDSCAPE_HEIGHT - 145, &(adddressMicrochip[0][0]) );
        
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_FONT_MEDIUM, USB_NULL, 0, 0 );
        
                            WriteLine( 100, PRINTER_PAGE_LANDSCAPE_HEIGHT - 120, &(adddressMicrochip[1][0]) );
                            WriteLine( 100, PRINTER_PAGE_LANDSCAPE_HEIGHT - 95, &(adddressMicrochip[2][0]) );
                            WriteLine( 100, PRINTER_PAGE_LANDSCAPE_HEIGHT - 70, &(adddressMicrochip[3][0]) );
        
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_FONT_NAME, USB_NULL, USB_PRINTER_FONT_AVANT_GARDE, 0 );
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_FONT_SIZE, USB_NULL, (DWORD)24, 0 );
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_FONT_BOLD, USB_NULL, 0, 0 );
        
                            WriteLine( 450, 125, &(businessCard[0][0]) );
        
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_FONT_MEDIUM, USB_NULL, 0, 0 );
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_FONT_SIZE, USB_NULL, (DWORD)20, 0 );

                            WriteLine( 450, 150, &(businessCard[1][0]) );
                            WriteLine( 450, 175, &(businessCard[2][0]) );
                            WriteLine( 450, 200, &(businessCard[3][0]) );
                            WriteLine( 450, 225, &(businessCard[4][0]) );
                            WriteLine( 450, 250, &(businessCard[5][0]) );
                            WriteLine( 450, 275, &(businessCard[6][0]) );
                            WriteLine( 450, 300, &(businessCard[7][0]) );
        
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_FONT_NAME, USB_NULL, USB_PRINTER_FONT_PALATINO, 0 );
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_FONT_SIZE, USB_NULL, (DWORD)16, 0 );
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_FONT_ITALIC, USB_NULL, 0, 0 );
        
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_GRAPHICS_LINE_WIDTH, USB_NULL, PRINTER_LINE_WIDTH_NORMAL, 0 );
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_GRAPHICS_LINE_TYPE, USB_NULL, PRINTER_LINE_TYPE_DASHED, 0 );

                            WriteLine( 120, 310, &(notes[0][0]) );
                            params.sLine.x1 = 170;
                            params.sLine.y1 = 290;
                            params.sLine.x2 = 220;
                            params.sLine.y2 = 260;
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_GRAPHICS_LINE, USB_DATA_POINTER_RAM(&params), sizeof(params.sLine), 0 );
        
                            WriteLine( 216, 396, &(notes[1][0]) );
                            params.sLine.x1 = 266;
                            params.sLine.y1 = 400;
                            params.sLine.x2 = 216;
                            params.sLine.y2 = 445;
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_GRAPHICS_LINE, USB_DATA_POINTER_RAM(&params), sizeof(params.sLine), 0 );
        
                            WriteLine( 440, 330, &(notes[2][0]) );
                            params.sLine.x1 = 490;
                            params.sLine.y1 = 310;
                            params.sLine.x2 = 515;
                            params.sLine.y2 = 280;
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_GRAPHICS_LINE, USB_DATA_POINTER_RAM(&params), sizeof(params.sLine), 0 );
        
                            WriteLine( 450, 410, &(notes[3][0]) );
                            params.sLine.x1 = 550;
                            params.sLine.y1 = 415;
                            params.sLine.x2 = 590;
                            params.sLine.y2 = 430;
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_GRAPHICS_LINE, USB_DATA_POINTER_RAM(&params), sizeof(params.sLine), 0 );
                            params.sLine.x1 = 500;
                            params.sLine.y1 = 415;
                            params.sLine.x2 = 500;
                            params.sLine.y2 = 540;
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_GRAPHICS_LINE, USB_DATA_POINTER_RAM(&params), sizeof(params.sLine), 0 );

                            #define TAO_UNIT    4
                            #define TAO_XL      (PRINTER_PAGE_LANDSCAPE_WIDTH - 200)
                            #define TAO_YT      (PRINTER_PAGE_LANDSCAPE_HEIGHT - 200)
                            #define TAO_XC      (TAO_XL + TAU_UNIT * 12)
                            #define TAO_YC      (TAO_YL + TAU_UNIT * 12)
        
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_GRAPHICS_LINE_WIDTH, USB_NULL, PRINTER_LINE_WIDTH_NORMAL, 0 );
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_GRAPHICS_LINE_TYPE, USB_NULL, PRINTER_LINE_TYPE_SOLID, 0 );
        
                            params.sArc.xL       = TAO_XL;
                            params.sArc.yT       = TAO_YT;
                            params.sArc.xR       = TAO_XL + TAO_UNIT * 24;
                            params.sArc.yB       = TAO_YT + TAO_UNIT * 24;
                            params.sArc.r1       = 0;
                            params.sArc.r2       = TAO_UNIT * 12;
                            params.sArc.octant   = 0xF0;
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_GRAPHICS_ARC, USB_DATA_POINTER_RAM(&params), sizeof(params.sArc), 0 );
        
                            params.sCircle.x    = TAO_XL + TAO_UNIT * 12;
                            params.sCircle.y    = TAO_YT + TAO_UNIT * 18;
                            params.sCircle.r    = TAO_UNIT * 6;
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_GRAPHICS_CIRCLE_FILLED, USB_DATA_POINTER_RAM(&params), sizeof(params.sCircle), 0 );
        
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_GRAPHICS_COLOR, USB_NULL, PRINTER_COLOR_WHITE, 0 );

                            params.sCircle.x    = TAO_XL + TAO_UNIT * 12;
                            params.sCircle.y    = TAO_YT + TAO_UNIT * 6;
                            params.sCircle.r    = TAO_UNIT * 6;
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_GRAPHICS_CIRCLE_FILLED, USB_DATA_POINTER_RAM(&params), sizeof(params.sCircle), 0 );
        
                            params.sCircle.x    = TAO_XL + TAO_UNIT * 12;
                            params.sCircle.y    = TAO_YT + TAO_UNIT * 18;
                            params.sCircle.r    = TAO_UNIT;
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_GRAPHICS_CIRCLE_FILLED, USB_DATA_POINTER_RAM(&params), sizeof(params.sCircle), 0 );
        
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_GRAPHICS_COLOR, USB_NULL, PRINTER_COLOR_BLACK, 0 );
        
                            params.sCircle.x    = TAO_XL + TAO_UNIT * 12;
                            params.sCircle.y    = TAO_YT + TAO_UNIT * 6;
                            params.sCircle.r    = TAO_UNIT;
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_GRAPHICS_CIRCLE_FILLED, USB_DATA_POINTER_RAM(&params), sizeof(params.sCircle), 0 );
        
                            params.sCircle.x    = TAO_XL + TAO_UNIT * 12;
                            params.sCircle.y    = TAO_YT + TAO_UNIT * 12;
                            params.sCircle.r    = TAO_UNIT * 12;
                            USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_GRAPHICS_CIRCLE, USB_DATA_POINTER_RAM(&params), sizeof(params.sCircle), 0 );
                        }
        
                        // Terminate
                        UART2PrintString( "Demo complete.\r\n" );
                        USBHostPrinterCommandWithReadyWait( &returnCode, printerInfo.deviceAddress, USB_PRINTER_JOB_STOP, USB_NULL, 0, 0 );
                    }
                }
            }
        }

    }
}
Exemple #11
0
static BOOL hid_device_read(BYTE deviceAddress, void *data)
{
    // call usb host layer
    USBTasks();

    // Was device detached?
    // Or, was report descriptor parsed with error.?
    if(!USBHostHIDDeviceDetect(deviceAddress)){
        App_State[deviceAddress] = DEVICE_NOT_CONNECTED;
    }

    switch(App_State[deviceAddress]){
        case DEVICE_NOT_CONNECTED:
            USBTasks();
            /* True if report descriptor is parsed with no error */
            if(USBHostHIDDeviceDetect(deviceAddress)){
                App_State[deviceAddress] = DEVICE_CONNECTED;
            }
            break;

        case DEVICE_CONNECTED:
            App_State[deviceAddress] = READY_TO_TX_RX_REPORT;
            break;

        case READY_TO_TX_RX_REPORT:
            if(USBHostHIDDeviceDetect(deviceAddress)){
                App_State[deviceAddress] = GET_INPUT_REPORT;
            }else{
                App_State[deviceAddress] = DEVICE_NOT_CONNECTED;
            }
            break;

        case GET_INPUT_REPORT:
            if(!USBHostHIDRead(deviceAddress, Appl_raw_report_buffer[deviceAddress].Report_ID,0,
                    Appl_raw_report_buffer[deviceAddress].ReportSize, Appl_raw_report_buffer[deviceAddress].ReportData)){
                App_State[deviceAddress] = INPUT_REPORT_PENDING;
            }
            break;

        case INPUT_REPORT_PENDING:
            if(USBHostHIDTransferIsComplete(deviceAddress, &ErrorDriver[deviceAddress],&NumOfBytesRcvd[deviceAddress])){
                if(ErrorDriver[deviceAddress] ||(NumOfBytesRcvd[deviceAddress] != Appl_raw_report_buffer[deviceAddress].ReportSize )){
                    ErrorCounter[deviceAddress]++ ;
                    if(MAX_ERROR_COUNTER <= ErrorDriver[deviceAddress]){
                        App_State[deviceAddress] = ERROR_REPORTED;
                    }else{
                        App_State[deviceAddress] = READY_TO_TX_RX_REPORT;
                    }
                }else{
                    ErrorCounter[deviceAddress] = 0;
                    ReportBufferUpdated[deviceAddress] = TRUE;
                    App_State[deviceAddress] = READY_TO_TX_RX_REPORT;

                    App_ProcessInputReport(deviceAddress, data);
                    App_PrepareOutputReport(deviceAddress);
                    return TRUE;
                }
            }
            break;

        case SEND_OUTPUT_REPORT: /* Will be done while implementing Keyboard */
            if(!USBHostHIDWrite(deviceAddress, Appl_LED_Indicator[deviceAddress].reportID, Appl_LED_Indicator[deviceAddress].interfaceNum, Appl_LED_Indicator[deviceAddress].reportLength,
                    (BYTE*)&Appl_led_report_buffer[deviceAddress])){
                App_State[deviceAddress] = OUTPUT_REPORT_PENDING;
            }
            break;

        case OUTPUT_REPORT_PENDING:
            if(USBHostHIDTransferIsComplete(deviceAddress, &ErrorDriver[deviceAddress],&NumOfBytesRcvd[deviceAddress])){
                if(ErrorDriver[deviceAddress]){
                    ErrorCounter[deviceAddress]++ ;
                    if(MAX_ERROR_COUNTER <= ErrorDriver[deviceAddress]){
                        App_State[deviceAddress] = ERROR_REPORTED;
                    }
                }else{
                    ErrorCounter[deviceAddress] = 0;
                    App_State[deviceAddress] = READY_TO_TX_RX_REPORT;
                }
            }
            break;

        case ERROR_REPORTED:	// forever error loop
            break;

        default:
            break;
    }

    // ReportData isn't ready!
    return FALSE;
}
Exemple #12
0
void hidTask (void)
{
    BYTE i;
    int deviceValue = 0;
    USBTasks();
    App_Detect_Device();
    switch (App_State_Mouse_Keyboard) {
        case DEVICE_NOT_CONNECTED:
            connectedDevice = DEVICE_NOT_CONNECTED_OR_NOT_SUPPORTED;
            USBTasks();
            if (DisplayDeatachOnce == FALSE) {
                DisplayDeatachOnce = TRUE;
            }
            if (USBHostHID_ApiDeviceDetect()) {
                DisplayConnectOnce = FALSE;
                deviceValue = USBHID_ReportDecriptor_Difference();
                if (deviceValue == USB_HID_MOUSE) {
                    App_State_Mouse_Keyboard = MOUSE_DEVICE_CONNECTED;
                } else if (deviceValue == USB_HID_KEYBOARD) {
                    App_State_Mouse_Keyboard = KEYBOARD_DEVICE_CONNECTED;
                }

            }

            break;
        case MOUSE_DEVICE_CONNECTED:
            UART2PrintString("\r\n");
            UART2PrintString(UHP_MOUSE_CONNECTED);
            UART2PrintString("\r\n");
            connectedDevice = DEVICE_MOUSE;
            App_State_Mouse_Keyboard = MOUSE_READY_TO_TX_RX_REPORT;
            if (DisplayConnectOnce == FALSE) {
                DisplayConnectOnce = TRUE;
                DisplayDeatachOnce = FALSE;
            }

            break;

        case KEYBOARD_DEVICE_CONNECTED:
            UART2PrintString("\r\n");
            UART2PrintString(UHP_KEYBOARD_CONNECTED);
            UART2PrintString("\r\n");
            connectedDevice = DEVICE_KEYBOARD;
            App_State_Mouse_Keyboard = KEYBOARD_READY_TO_TX_RX_REPORT;
            if (DisplayConnectOnce == FALSE) {
                DisplayConnectOnce = TRUE;
                DisplayDeatachOnce = FALSE;
            }

            InitializeTimer();

            break;
        case MOUSE_READY_TO_TX_RX_REPORT:
            if (!USBHostHID_ApiDeviceDetect()) {
                App_State_Mouse_Keyboard = DEVICE_NOT_CONNECTED;
            } else {
                App_State_Mouse_Keyboard = MOUSE_GET_INPUT_REPORT;
            }

            break;
        case KEYBOARD_READY_TO_TX_RX_REPORT:
            if (!USBHostHID_ApiDeviceDetect()) {
                App_State_Mouse_Keyboard = DEVICE_NOT_CONNECTED;
            }


            break;
        case MOUSE_GET_INPUT_REPORT:
            if (USBHostHID_ApiGetReport(Appl_raw_report_buffer.Report_ID, 0,
                    Appl_raw_report_buffer.ReportSize, Appl_raw_report_buffer.ReportData)) {
                // Host may be busy/error -- keep trying
            } else {
                App_State_Mouse_Keyboard = MOUSE_INPUT_REPORT_PENDING;
            }
            USBTasks();
            break;
        case KEYBOARD_GET_INPUT_REPORT:
            if (USBHostHID_ApiGetReport(Appl_raw_report_buffer.Report_ID, Appl_ModifierKeysDetails.interfaceNum,
                    Appl_raw_report_buffer.ReportSize, Appl_raw_report_buffer.ReportData)) {
                /* Host may be busy/error -- keep trying */
            } else {
                App_State_Mouse_Keyboard = KEYBOARD_INPUT_REPORT_PENDING;
            }
            USBTasks();
            break;
        case MOUSE_INPUT_REPORT_PENDING:
            if (USBHostHID_ApiTransferIsComplete(&ErrorDriver, &NumOfBytesRcvd)) {
                if (ErrorDriver || (NumOfBytesRcvd != Appl_raw_report_buffer.ReportSize)) {
                    ErrorCounter++;
                    if (MAX_ERROR_COUNTER <= ErrorDriver)
                        App_State_Mouse_Keyboard = ERROR_REPORTED;
                    else
                        App_State_Mouse_Keyboard = MOUSE_READY_TO_TX_RX_REPORT;
                } else {
                    ErrorCounter = 0;
                    ReportBufferUpdated = TRUE;
                    App_State_Mouse_Keyboard = MOUSE_READY_TO_TX_RX_REPORT;

                    if (DisplayConnectOnce == TRUE) {
                        for (i = 0; i < Appl_raw_report_buffer.ReportSize; i++) {
                            if (Appl_raw_report_buffer.ReportData[i] != 0) {
                                DisplayConnectOnce = FALSE;
                            }
                        }
                    }

                    App_ProcessInputReport_Mouse();
                }
            }

            break;
        case KEYBOARD_INPUT_REPORT_PENDING:
            if (USBHostHID_ApiTransferIsComplete(&ErrorDriver, &NumOfBytesRcvd)) {
                if (ErrorDriver || (NumOfBytesRcvd != Appl_raw_report_buffer.ReportSize)) {
                    ErrorCounter++;
                    if (MAX_ERROR_COUNTER <= ErrorDriver) {
                        App_State_Mouse_Keyboard = ERROR_REPORTED;
                    } else {
                        App_State_Mouse_Keyboard = KEYBOARD_READY_TO_TX_RX_REPORT;
                    }
                } else {
                    ErrorCounter = 0;
                    ReportBufferUpdated = TRUE;
                    App_State_Mouse_Keyboard = KEYBOARD_READY_TO_TX_RX_REPORT;

                    if (DisplayConnectOnce == TRUE) {
                        for (i = 0; i < Appl_raw_report_buffer.ReportSize; i++) {
                            if (Appl_raw_report_buffer.ReportData[i] != 0) {
                                DisplayConnectOnce = FALSE;
                            }
                        }
                    }

                    App_ProcessInputReport_Keyboard();
                    App_PrepareOutputReport();
                }
            }
            break;
        case SEND_OUTPUT_REPORT: /* Will be done while implementing Keyboard */
            if (USBHostHID_ApiSendReport(Appl_LED_Indicator.reportID, Appl_LED_Indicator.interfaceNum, Appl_LED_Indicator.reportLength,
                    (BYTE*) & Appl_led_report_buffer)) {
                /* Host may be busy/error -- keep trying */
            } else {
                App_State_Mouse_Keyboard = OUTPUT_REPORT_PENDING;
            }
            USBTasks();

            break;
        case OUTPUT_REPORT_PENDING:
            if (USBHostHID_ApiTransferIsComplete(&ErrorDriver, &NumOfBytesRcvd)) {
                if (ErrorDriver) {
                    ErrorCounter++;
                    if (MAX_ERROR_COUNTER <= ErrorDriver)
                        App_State_Mouse_Keyboard = ERROR_REPORTED;
                } else {
                    ErrorCounter = 0;
                    App_State_Mouse_Keyboard = KEYBOARD_READY_TO_TX_RX_REPORT;
                }
            }
            break;
        case ERROR_REPORTED:
            break;
        default:
            break;

    }
}
Exemple #13
0
/******************************************************************************
 * Function:        void main(void)
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        Main program entry point.
 *
 * Note:            None
 *****************************************************************************/
void main(void)
{
 
//do some startup tasks...

		InitializeSystem();


//small delay for things to cook up


	for (b=0;b<1026;b++)
			{
				Delay1KTCYx(1);
			}



//start I2C system at 100 Khz speed
	initi2c();


//board default configuration registers are changed here
//make changed to loafconfigfriendly for a more friendly version
 loadconfig();


//
//setup your IO configuration
//
// NOTE: you should change this 1st before anything else
// this allows you to change ports to input, output, or analog
// this function is in user.c
//
loadconfigfriendly();


for (c=0;c<10;c++)
{

//small delay for things to cook up
	for (b=0;b<1036;b++)
			{
				Delay1KTCYx(10);
			}
}

//start the USART module at 57600 buad rate
	startUsart(200000);  


//small delay for things to cook up
	for (b=0;b<1026;b++)
			{
				Delay1KTCYx(10);
			}



//test xbee module at given baudrate of 57600
	if (testxbee())
	{

		//57600 baud failed so lets test to see if its a new module
		//start the USART module at 9600 buad rate
		startUsart(9600);  

		//small delay for things to cook up
		for (b=0;b<1060;b++)
		{
			Delay1KTCYx(1);
		}
		//testing xbee at 9600 baudrate
		if (testxbee())
		{

		//LOOP FOR NO XBEE MODULE FOUND (FAILED AT BOTH BAUDRATES)
		//xbee module failed at 9600 baud so no module present at either baudrate
		//new modules come with a 9600 baud rate by default.
		//
		//this is the no module operating code in here, put what you want when no module present
		//can use as a regular controller or PLC.
			//
			//	NO XBEE MODULE FOUND MAIN LOOP STARTS HERE
			//

			mInitializeUSBDriver(); 


			for(c=0;c<60;c++)
			{
				for (b=0;b<1060;b++)
				{
					Delay1KTCYx(1);
					USBTasks(); 
					ProcessIO(); 
				}
			}



			while(1)
			{
				//small delay so dont roast the USB system too much 
				Delay1KTCYx(10);

				//USB polling tasks optional

				for (b=0;b<1060;b++)
				{
					Delay1KTCYx(1);
					USBTasks(); 
					ProcessIO(); 
				}


		
			//
			//  NO XBEE MODULE FOUND MAIN LOOP ENDS HERE
			//
			} //end no xbee found main loop
//END LOOP
		}
		//found module at 9600 baud rate
        //
        //now we will change the baud rate to 57600 in the module to speed things up
		else
		{
				//small delay for things to cook up
				for (b=0;b<1060;b++)
				{
					Delay1KTCYx(20);
				}


			//change xbee module to 57600 baud rate
			changebaudrate();

			//start the USART module at 57600 buad rate
			startUsart(200000);

			for (c=0;c<30;c++)
			{

				//small delay for things to cook up
				for (b=0;b<3000;b++)
				{
					Delay1KTCYx(1);
				}
			}

	   	

			//initialize xbee module to the paramters specified in the following function
			//
			// NOTE: you need to edit this function to tailor this node's network parameters and such
			// this function is found in user.c
      		//			

			initxbee();

		}

	}
	//found xbee module at 57600 baud rate
	else
	{
		//initialize xbee module to the paramters specified in the following function
		//
		// NOTE: you need to edit this function to tailor this node's network parameters and such
		// this function is found in user.c
        //

		//small delay for things to cook up
		for (b=0;b<1026;b++)
			{
				Delay1KTCYx(10);
			
			}


		initxbee();
	}
	


	


	//configure xbee sleep mode here but it is not written to non volatile memory
 	//since may have problems re-entering command mode later on!!
    //sleep_config_xbee();





//put xbee to not pin sleep 
	xbee_sleep=0; //put module to not sleep!! (edge triggeered wakeup)





//shutoff USB module to save 8 mA current
//...uncomment to turn module off

//		UCONbits.USBEN=0;
//		UCONbits.SUSPND=1;	


//uncomment to turn USB on
   		mInitializeUSBDriver(); 
//end usb turn on



	for(c=0;c<40;c++)
	{
		for (b=0;b<1060;b++)
		{
				Delay1KTCYx(1);
				USBTasks(); 
				ProcessIO(); 
		}
	}



// set processor primary idle mode (not sleep!!)
//	  	OSCCONbits.IDLEN=1;


//start timer 1 to time periodic functions
  		starttimer();


//start USART receive interrupt
		PIE1bits.RCIE=1;



//MAIN LOOP FOR XBEE MODULE NORMAL
	//
	//	START MAIN LOOP FOR XBEE MODULE FOUND AT 200 K BAUD AND INTIALIZED TO YOUR PARAMETERS
	//



    while(1)
    {

	
		//loop to service USB requests (polling)
		for (b=0;b<1060;b++)
		{
				Delay1KTCYx(1);

		//service USB tasks
				USBTasks(); 
				ProcessIO(); 
		}

	}//end while

	//
	//  END MAIN LOOP FOR XBEE MODULE FOUND AT 57600 BAUD AND INITIALIZED TO YOUR PARAMETERS
	//
//END LOOP


}//end main
Exemple #14
0
static void file_flash(FSFILE* file)
{
	UINT readBytes;
	UINT i;

	// Erase Flash (Block Erase the program Flash)
	if (NVMemBlockErase() != 0)
	{
		error(ERR_NV_ERASE);
	}

	record.status = REC_NOT_FOUND;      // Initialize the state-machine to read the records.

	while (1)
	{
		USBTasks();
		BlinkBlueLED();
		BlinkOrangeLED();

		// For a faster read, fetch 512 bytes at a time and buffer it.
		readBytes = FSfread((void*)&asciiBuffer[pointer], 1, 512, file);

		if (readBytes == 0)
		{
			// Nothing to read. Come out of this loop
			// break;
			// Jump to start of application
			// Disable all enabled interrupts (only USB)
			// before jumping to the application code.
			IEC5bits.USB1IE = 0;
//			JumpToApp();
			return;
		}

		for (i = 0; i < (readBytes + pointer); i ++)
		{
			// This state machine seperates-out the valid hex records from the read 512 bytes.
			switch (record.status)
			{
			case REC_FLASHED:
			case REC_NOT_FOUND:
				if (asciiBuffer[i] == ':')
				{
					// We have a record found in the 512 bytes of data in the buffer.
					record.start = &asciiBuffer[i];
					record.len = 0;
					record.status = REC_FOUND_BUT_NOT_FLASHED;
				}
				break;
			case REC_FOUND_BUT_NOT_FLASHED:
				if ((asciiBuffer[i] == 0x0A) || (asciiBuffer[i] == 0xFF))
				{
					// We have got a complete record. (0x0A is new line feed and 0xFF is End of file)
					// Start the hex conversion from element
					// 1. This will discard the ':' which is
					// the start of the hex record.
					ConvertAsciiToHex(&record.start[1], hexRec);
					WriteHexRecord2Flash(hexRec);
					record.status = REC_FLASHED;
				}
				break;
			}
			record.len ++;  // Move to next byte in the buffer.
		}

		if (record.status == REC_FOUND_BUT_NOT_FLASHED)
		{
			// We still have a half read record in the buffer. The next half part of the record is read 
			// when we read 512 bytes of data from the next file read. 
			memcpy(asciiBuffer, record.start, record.len);
			pointer = record.len;
			record.status = REC_NOT_FOUND;
		}
		else
		{
			pointer = 0;
		}
	}
}
Exemple #15
0
/****************************************************************************
  Function:
    BOOT_LOADER_RETURN_CODES EnterBootLoaderMode(void* handle)

  Description:
    This routine is the main state machine for the bootloader.

  Precondition:
    The device is attached and has been detected.

  Parameters:
    void* handle            - A generic pointer to the attached device

  Returns:
    BOOT_SUCCESS            - Device has been successfully Booted
                              (may still have a validation error, though)
    BOOT_DEVICE_DETACHED    - Device has been detached before Bootloading finished
    BOOT_UNKNOWN_ERROR      - An unknown error occurred with USB transfers
***************************************************************************/
BOOT_LOADER_RETURN_CODES EnterBootLoaderMode(void* handle)
{
    BYTE errorCode;
    DWORD size;
    DWORD_VAL status;
    BOOT_LOADER_STATE state = BOOT_START;
    
    // Device was attached when this function was called
    device_attached = TRUE;
    
    // Run loop
    while(1)
    {
        //Keep the USB stack running
        USBTasks();
        
        // Return, if the device has been detached
        if(device_attached == FALSE)
        {
           return BOOT_DEVICE_DETACHED;
        }
        
        // Bootloader state machine
        switch(state)
        {
            case BOOT_START:
                // Try to read from the attached Android device
                if(AndroidAppRead(handle, data, sizeof(data)) != USB_SUCCESS)
                {
                    state = BOOT_ERROR;             // update state to error, if unsuccessful
                }
                else
                {
                    state = BOOT_ENTER_WAIT;        // Otherwise, wait until read is complete
                }
                break;
    
            case BOOT_ENTER_WAIT:
                // If read from Android device is complete
                if(AndroidAppIsReadComplete(handle, &errorCode, &size) == TRUE)
                {
                    // Then check to see if there was an error
                    if(errorCode != USB_SUCCESS)
                    {
                        state = BOOT_ERROR;             // Update state to error if there was an error
                    }
                    else
                    {
                        // Otherwise check the first byte in the packet to see if it was START_BOOT_REQ
                        if(data[0] != START_BOOT_REQ)
                        {
                            state = BOOT_ERROR;         // If not, then an error occurred
                        }
                        else
                        {
                            state = READ_FILE_REQ_SEND; // If so, then update state to send READ_FILE_REQ
                        }
                    }                
                }
                break;
    
            case READ_FILE_REQ_SEND:
                // Set the first byte of the packet to READ_FILE_REQ
                data[0] = READ_FILE_REQ;
                
                // And send packet to the Android device
                if(AndroidAppWrite(handle, data, 1) != USB_SUCCESS)
                {
                    state = BOOT_ERROR;             // If unsuccessful, then update state to error
                }
                else
                {
                    state = READ_FILE_REQ_WAIT;     // Otherwise wait until write is complete
                }
                break;
    
            case READ_FILE_REQ_WAIT:
                // If the write is complete
                if(AndroidAppIsWriteComplete(handle, &errorCode, &size) == TRUE)
                {
                    // Then check for errors
                    if(errorCode != USB_SUCCESS)
                    {
                        state = BOOT_ERROR;     // If there was an error, update state to error
                    }
                    else
                    {
                        state = READING_DATA;   // Otherwise start reading data that contains flash update
                    }
                }
                break;
    
            case READING_DATA:
                // Try to read enough to fill the buffer
                if(AndroidAppRead(handle, data, sizeof(data)) != USB_SUCCESS)
                {
                    state = BOOT_ERROR;         // Update state to error if unsuccessful
                }
                else
                {
                    state = READING_DATA_WAIT;  // Otherwise wait until the read is successful
                }
                break;
    
            case READING_DATA_WAIT:
                // If the read was successful
                if(AndroidAppIsReadComplete(handle, &errorCode, &size) == TRUE)
                {
                    // Then check to see if there were any errors
                    if(errorCode != USB_SUCCESS)
                    {
                        state = BOOT_ERROR;         // If so, then update state to error
                    }
                    else
                    {
                        state = FLASHING_DATA;      // Otherwise start re-flashing the new data into program memory
                    }                
                }
                break;
    
            case FLASHING_DATA:
                // Write the data from the buffer to program memory
                status.Val = CustomBinWrite(data,size);
                
                // If there is more to read from the Android device
                if(status.Val == DONE_WRITING_BUFFER)
                {
                    state = READING_DATA;           // Then update state to reading data
                }
                else
                {
                    state = LOAD_COMPLETE_RSP_SEND; // Otherwise update state to send load complete response
                }
                break;
                
            case LOAD_COMPLETE_RSP_SEND:
                // Write LOAD_COMPLETE_RSP command to first byte, and status of the write to the rest of the packet
                data[0] = LOAD_COMPLETE_RSP;
                data[1] = status.byte.MB;
                data[2] = status.byte.UB;
                data[3] = status.byte.HB;
                data[4] = status.byte.LB;
                
                // Send to Android device
                if(AndroidAppWrite(handle, data, 5) != USB_SUCCESS)
                {
                    state = BOOT_ERROR;             // If there are any errors, update state to error
                }
                else
                {
                    state = LOAD_COMPLETE_RSP_WAIT; // Otherwise, wait until write is complete
                }
                break;
    
            case LOAD_COMPLETE_RSP_WAIT:
                // If the write is finished
                if(AndroidAppIsWriteComplete(handle, &errorCode, &size) == TRUE)
                {
                    // Then check for errors
                    if(errorCode != USB_SUCCESS)
                    {
                        state = BOOT_ERROR;         // If there was an error, update state to error
                    }
                    else
                    {
                        return BOOT_SUCCESS;        // Otherwise return with BOOT_SUCCESS
                    }
                }
                break;
    
            case BOOT_ERROR:
                // If there was an error, then return BOOT_UNKNOWN_ERROR
                return BOOT_UNKNOWN_ERROR;
                break;
        } //switch
    } //while(1)
    
    return BOOT_UNKNOWN_ERROR;
}
Exemple #16
0
/****************************************************************************
  Function:
    int main(void)

  Summary:
    main function

  Description:
    main function

  Precondition:
    None

  Parameters:
    None

  Return Values:
    int - exit code for main function

  Remarks:
    None
  ***************************************************************************/
int main(void)
{
    DWORD size = 0;
    BOOL responseNeeded;

    BYTE mode = 0;

    BYTE wasMode = 0;
    BYTE pushButtonValues = 0xFF;
    BYTE potPercentage = 0xFF;
    BOOL buttonsNeedUpdate = FALSE;
    BOOL potNeedsUpdate = FALSE;
    BOOL motorON = FALSE;
    BOOL readyToRead = TRUE;
    BOOL writeInProgress = FALSE;
    BYTE tempValue = 0xFF;
    BYTE errorCode;
    ACCESSORY_APP_PACKET* command_packet = NULL;

    CLKDIV =  0; /* set for default clock operations Fcyc = 4MHz */
    AD1PCFGL = 0xffff;
    AD1PCFGH = 0x0003;

    BOOL connected_to_app = FALSE;
    BOOL need_to_disconnect_from_app = FALSE;

    #if defined(__PIC32MX__)
        InitPIC32();
    #endif

  #if defined(__dsPIC33EP512MU810__) || defined (__PIC24EP512GU810__)

    // Configure the device PLL to obtain 60 MIPS operation. The crystal
    // frequency is 8MHz. Divide 8MHz by 2, multiply by 60 and divide by
    // 2. This results in Fosc of 120MHz. The CPU clock frequency is
    // Fcy = Fosc/2 = 60MHz. Wait for the Primary PLL to lock and then
    // configure the auxilliary PLL to provide 48MHz needed for USB
    // Operation.

	PLLFBD = 38;				/* M  = 60	*/
	CLKDIVbits.PLLPOST = 0;		/* N1 = 2	*/
	CLKDIVbits.PLLPRE = 0;		/* N2 = 2	*/
	OSCTUN = 0;

    /*	Initiate Clock Switch to Primary
     *	Oscillator with PLL (NOSC= 0x3)*/

    __builtin_write_OSCCONH(0x03);
	__builtin_write_OSCCONL(0x01);
	while (OSCCONbits.COSC != 0x3);

    // Configuring the auxiliary PLL, since the primary
    // oscillator provides the source clock to the auxiliary
    // PLL, the auxiliary oscillator is disabled. Note that
    // the AUX PLL is enabled. The input 8MHz clock is divided
    // by 2, multiplied by 24 and then divided by 2. Wait till
    // the AUX PLL locks.

    ACLKCON3 = 0x24C1;
    ACLKDIV3 = 0x7;
    ACLKCON3bits.ENAPLL = 1;
    while(ACLKCON3bits.APLLCK != 1);

    TRISBbits.TRISB5 = 0;
    LATBbits.LATB5 = 1;

    #endif

    USBInitialize(0);
    AndroidAppStart(&myDeviceInfo);

    responseNeeded = FALSE;
    mInitPOT();
    InitializeTimer2For_PWM();
    PwmInit();

    //InitMOTOR();

    DEBUG_Init(0);

    InitAllLEDs();

    while(1)
    {
        //Keep the USB stack running
        USBTasks();



        //If the device isn't attached yet,
        if(device_attached == FALSE || mode == 1)
        {
            buttonsNeedUpdate = TRUE;
            potNeedsUpdate = TRUE;
            need_to_disconnect_from_app = FALSE;
            connected_to_app = FALSE;
            size = 0;

            /**/
            BYTE curPush = GetPushbuttons();

            if ((curPush == 0x8) || (mode == 1)) {
                LED0_On();

                mode = 1;
                if (wasMode == 0) {

                    pot2LEDs();
                    PwmInit();


                }

                tempValue = ReadPOT();


                wasMode = 1;

                //If it is different than the last time we read the pot, then we need
                //  to send it to the Android device

                if(tempValue != potPercentage) {
                    potNeedsUpdate = TRUE;
                    //setRPM(tempValue);

                    setPWM();
                }
            }
            if ((curPush == 0x4)  || (mode == 0)) {
                    mode = 0;
                    //LED0_Off();

                    if (wasMode == 1) {
                        SetLEDs(0b00000000);
                        wasMode = 0;
                        setRPM(0);
                    }
                    //Reset the accessory state variables
                    InitAllLEDs();

                    //Continue to the top of the while loop to start the check over again.
                    continue;
                }
               /* //Reset the accessory state variables
                InitAllLEDs();

                //Continue to the top of the while loop to start the check over again.
                continue;
            }*/
            //}






        }

        //If the accessory is ready, then this is where we run all of the demo code

        if(readyToRead == TRUE && mode == 0)
        {
            errorCode = AndroidAppRead(device_handle, (BYTE*)&read_buffer, (DWORD)sizeof(read_buffer));
            //If the device is attached, then lets wait for a command from the application
            if( errorCode != USB_SUCCESS)
            {
                //Error
                DEBUG_PrintString("Error trying to start read");
            }
            else
            {
                readyToRead = FALSE;
            }
        }

        size = 0;

        if(AndroidAppIsReadComplete(device_handle, &errorCode, &size) == TRUE)
        {
            //We've received a command over the USB from the Android device.
            if(errorCode == USB_SUCCESS)
            {
                //Maybe process the data here.  Maybe process it somewhere else.
                command_packet = (ACCESSORY_APP_PACKET*)&read_buffer[0];
            }
            else
            {
                //Error
                DEBUG_PrintString("Error trying to complete read request");
            }

        }

        while(size > 0)
        {
            if(connected_to_app == FALSE)
            {
                if(command_packet->command == COMMAND_APP_CONNECT)
                {
                    connected_to_app = TRUE;
                    need_to_disconnect_from_app = FALSE;
                }
            }
            else
            {
                switch(command_packet->command)
                {
                    case COMMAND_SET_LEDS:
                        SetLEDs(command_packet->data);
                        break;

                    case COMMAND_APP_DISCONNECT:
                        need_to_disconnect_from_app = TRUE;
                        break;

                    case COMMAND_SET_PWM:
                        setRPM(command_packet->data);
                        break;

                    default:
                        //Error, unknown command
                        DEBUG_PrintString("Error: unknown command received");
                        break;
                }
            }
            //All commands in this example are two bytes, so remove that from the queue
            size -= 2;
            //And move the pointer to the next packet (this works because
            //  all command packets are 2 bytes.  If variable packet size
            //  then need to handle moving the pointer by the size of the
            //  command type that arrived.
            command_packet++;

            if(need_to_disconnect_from_app == TRUE)
            {
                break;
            }
        }

        if(size == 0)
        {
            readyToRead = TRUE;
        }

        //Get the current pushbutton settings
        tempValue = GetPushbuttons();

        //If the current button settings are different than the last time
        //  we read the button values, then we need to send an update to the
        //  attached Android device
        if(tempValue != pushButtonValues)
        {
            buttonsNeedUpdate = TRUE;
            pushButtonValues = tempValue;
        }

        //Get the current potentiometer setting
        tempValue = ReadPOT();

        //If it is different than the last time we read the pot, then we need
        //  to send it to the Android device
        if(tempValue != potPercentage)
        {
            potNeedsUpdate = TRUE;
            potPercentage = tempValue;
        }

        //If there is a write already in progress, we need to check its status
        if( writeInProgress == TRUE )
        {
            if(AndroidAppIsWriteComplete(device_handle, &errorCode, &size) == TRUE)
            {
                writeInProgress = FALSE;
                if(need_to_disconnect_from_app == TRUE)
                {
                    connected_to_app = FALSE;
                    need_to_disconnect_from_app = FALSE;
                }

                if(errorCode != USB_SUCCESS)
                {
                    //Error
                    DEBUG_PrintString("Error trying to complete write");
                }
            }
        }

        if((need_to_disconnect_from_app == TRUE) && (writeInProgress == FALSE))
        {
            outgoing_packet.command = COMMAND_APP_DISCONNECT;
            outgoing_packet.data = 0;
            writeInProgress = TRUE;

            errorCode = AndroidAppWrite(device_handle,(BYTE*)&outgoing_packet, 2);
            if( errorCode != USB_SUCCESS )
            {
                DEBUG_PrintString("Error trying to send button update");
            }
        }

        if(connected_to_app == FALSE)
        {
            //If the app hasn't told us to start sending data, let's not do anything else.
            continue;
        }

        //If we need up update the button status on the Android device and we aren't
        //  already busy in a write, then we can send the new button data.
        if((buttonsNeedUpdate == TRUE) && (writeInProgress == FALSE))
        {
            outgoing_packet.command = COMMAND_UPDATE_PUSHBUTTONS;
            outgoing_packet.data = pushButtonValues;



            errorCode = AndroidAppWrite(device_handle,(BYTE*)&outgoing_packet, 2);
            if( errorCode != USB_SUCCESS )
            {
                DEBUG_PrintString("Error trying to send button update");
            }

            buttonsNeedUpdate = FALSE;
            writeInProgress = TRUE;
        }

        //If we need up update the pot status on the Android device and we aren't
        //  already busy in a write, then we can send the new pot data.
        if((potNeedsUpdate == TRUE) && (writeInProgress == FALSE))
        {
            outgoing_packet.command = COMMAND_UPDATE_POT;
            outgoing_packet.data = potPercentage;

            errorCode = AndroidAppWrite(device_handle,(BYTE*)&outgoing_packet, 2);
            if( errorCode != USB_SUCCESS )
            {
                DEBUG_PrintString("Error trying to send pot update");
            }

            potNeedsUpdate = FALSE;
            writeInProgress = TRUE;
        }
    } //while(1) main loop
}
Exemple #17
0
/******************************************************************************
 * Function:        void UninitializedMain(void)
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        This is the main function for this bootloader mode firmware.
 *                  if execution gets to this function, it is assumed that we
 *                  want to stay in bootloader mode for now.
 *
 * Note:            If adding code to this function, make sure to add it only
 *                  after the C initializer like code at the top of this function.
 *****************************************************************************/
void BootMain(void)
{
	//NOTE: The c018.o file is not included in the linker script for this project.
	//The C initialization code in the c018.c (comes with C18 compiler in the src directory)
	//file is instead modified and included here manually.  This is done so as to provide
	//a more convenient entry method into the bootloader firmware.  Ordinarily the _entry_scn
	//program code section starts at 0x00 and is created by the code of c018.o.  However,
	//the linker will not work if there is more than one section of code trying to occupy 0x00.
	//Therefore, must not use the c018.o code, must instead manually include the useful code
	//here instead.

    //Make sure interrupts are disabled for this code (could still be on,
    //if the application firmware jumped into the bootloader via software methods)
    INTCON = 0x00;  

    // Initialize the C stack pointer, and other compiler managed items as normally done in the c018.c file.
	_asm
    lfsr 1, _stack
    lfsr 2, _stack
    clrf TBLPTRU, 0 
	_endasm

    //Clear the stack pointer, in case the user application jumped into 
    //bootloader mode with excessive junk on the call stack
    STKPTR = 0x00;  

	// End of the important parts of the C initializer.  This bootloader firmware does not use
	// any C initialized user variables (idata memory sections).  Therefore, the above is all
	// the initialization that is required.


    //Check if the USB module is already enabled.  If so, disable it and wait 
    //~100ms+ (>1 second recommended if CDC application firmware on XP), to 
    //ensure that the host has a chance to see and process the USB device detach 
    //event.
    if(UCONbits.USBEN == 1)
    {
        //USB module was already on.  This is likely because the user applicaiton
        //firmware jumped into this bootloader firmware using the absolute
        //software entry method, without first turning off the USB module
        DisableUSBandExecuteLongDelay(); 
    }    


    //Call other initialization code and (re)enable the USB module
    InitializeSystem();		//Some USB, I/O pins, and other initialization
    
    //Execute main loop
    while(1)
    {
		ClrWdt();
		
		//Need to call USBTasks() periodically.  This function takes care of 
		//processing non-USB application related USB packets (ex: "Chapter 9" 
		//packets associated with USB enumeration)
		USBTasks();             	    

		BlinkUSBStatus();   //When enabled, blinks LEDs on the board, based on USB bus state
		
		LowVoltageCheck();  //Regularly monitor voltage to make sure it is sufficient
		                    //for safe operation at full frequency and for erase/write
		                    //operations.		
		
		//Checks for and processes application related USB packets (assuming the
		//USB bus is in the CONFIGURED_STATE, which is the only state where
		//the host is allowed to send application related USB packets to the device.
	    if((usb_device_state == CONFIGURED_STATE) && (UCONbits.SUSPND != 1))
	    {
 	       ProcessIO();   // This is where all the actual bootloader related data transfer/self programming takes place
 	    }				  // see ProcessIO() function in the BootPIC[xxxx].c file.
    }//end while    
}    
Exemple #18
0
int main(void)
{
    int  value;
    int junk;
    millisec = 0;
    value = SYSTEMConfigWaitStatesAndPB( GetSystemClock() );

    // Enable the cache for the best performance
    CheKseg0CacheOn();

    //Setupt input for inteface button JF8 (RA01) (0x02)
    TRISASET = 0x02;
    //RED LED - JF9 (RA04)  (0x10)
    TRISACLR = 0x10;
    ODCACLR = 0x10;
    LATASET = 0x10;
    //Green LED -JF7 (RE9)  (0x200)
    TRISECLR = 0x200;
    ODCECLR = 0x200;
    LATESET = 0x200;
    //Setupt Input for DataFlag Button - JF10 - RA5 0x20
    TRISASET = 0x20;
    //Setup Output for Clutch Hold (Launch) JE1 RD14 0x4000
    //This function is active low, driving the FET on the PDU
    TRISDCLR = 0x4000;
    ODCDCLR = 0x4000;
    LATDSET = 0x4000; //Default state is high (off)

    CAN1Init();//CAN1 ACCL 500kbs
    CAN2Init();//Motec 1mbs
    DelayInit();

    initUART2(); // GPS UART
    prevButton1 = 0;
    prevButton2 = 0;
    millisec = 0;

   // Configure Timer 2 to request a real-time interrupt once per millisecond.
   // The period of Timer 2 is (16 * 5000)/(80 MHz) = 1 ms.
   OpenTimer2(T2_ON | T2_IDLE_CON | T2_SOURCE_INT | T2_PS_1_16 | T2_GATE_OFF, 5000);

   // Configure the CPU to respond to Timer 2's interrupt requests.
   INTEnableSystemMultiVectoredInt();
   INTSetVectorPriority(INT_TIMER_2_VECTOR, INT_PRIORITY_LEVEL_2);
   INTClearFlag(INT_T2);
   INTEnable(INT_T2, INT_ENABLED);

   //UART GPS Interrupts
   INTSetVectorPriority(INT_UART_2_VECTOR ,INT_PRIORITY_LEVEL_1); //Make sure UART interrupt is top priority
   INTClearFlag(INT_U2RX);
   INTEnable(INT_U2RX, INT_ENABLED);


    value = OSCCON;
    while (!(value & 0x00000020))
    {
        value = OSCCON;    // Wait for PLL lock to stabilize
    }

    deviceAttached = FALSE;

    //Initialize the stack
    USBInitialize(0);

    shouldLog = FALSE;
    shouldStop = FALSE;
    //count = 0;
    angularRateInfoRec = FALSE;
    accelerationSensorRec = FALSE;
    HRaccelerationSensorRec = FALSE;

       //init tim er 3 to convert adc at 100hz
    OpenTimer3(T3_ON|T3_PS_1_256|T3_SOURCE_INT, 1562);

    //initialize i2c for the psoc
    initI2CPSoC();
    
    state = wait;
    logNum = 0;

    initI2CEEPROM();
    short addy = 0x0000;
    BYTE num = 0x00;
    logNum = readEEPROM(addy);
    if(logNum >= 0xEF)  //Address stored in EEPROM  if greater than 0xEF reset to zero, limited to a single byte with current code configuration
    {
        writeEEPROM(addy, 0x00);
    }
    char GroupString[550];//Group Names (Line1)
    char UnitString[550];//Units (line2)
    char ParamString[650];//Paramater Names (line3)
    sprintf(GroupString,"Time,Accelerometer,Accelerometer,Accelerometer,Accelerometer,Accelerometer,Accelerometer,Accelerometer,Accelerometer,Accelerometer,Engine,Engine,Engine,Engine,Engine,Engine,Engine,Engine,Engine,Engine,Drivetrain,Drivetrain,Electrical,Drivetrain,Drivetrain,Drivetrain,Drivetrain,Engine,Engine,Engine,Engine,Electrical,Electrical,Electrical,Electrical,Electrical,Electrical,Suspension,Suspension,Suspension,Suspension,Suspension,Drivetrain,Driver\n");
    sprintf(UnitString,"ms,deg/s,deg/s,deg/s,m/s^2,m/s^2,m/s^2,m/s^2,m/s^2,m/s^2,rpm,%,kpa,degF,degF,lambda,psi,degF,na,na,psi,psi,V,mph,mph,mph,mph,s,gal,degF,degBTDC,mV,mV,mV,mV,mV,mV,mV,mV,mV,mV,mV,mV,\n");
    sprintf(ParamString, "Millisec,pitch(deg/sec),roll(deg/sec),yaw(deg/sec),lat(m/s^2),long(m/s^2),vert(m/s^2),latHR(m/s^2),longHR(m/s^2),vertHR(m/s^2),rpm,tps(percent),MAP(kpa),AT(degF),ect(degF),lambda,fuel pres,egt(degF),launch,neutral,brake pres,brake pres filtered,BattVolt(V),ld speed(mph), lg speed(mph),rd speed(mph),rg speed(mph),run time(s),fuel used,Oil Temp (deg F), Ignition Adv (degBTDC),Overall Consumption(mV),Overall Production(mV),Fuel Pump(mV),Fuel Injector(mV),Ignition(mV),Vref(mV),Back Left(mV),Back Right(mV),Front Left(mV),Front Right(mV),Steering Angle(mV),Brake Temp(mV),Data Flag,GPRMC,Time,Valid,Lat,N/S,Long,E/W,Speed,Course,Date,Variation,E/W\n");

    LATACLR = 0x10; //Turn on Red LED
   // LATECLR = 0x200;

    UARTSendString(UART2,PMTK_HOT_RESTART);
    int i = 0;
    while(!UARTTransmissionHasCompleted(UART2)){
        i++;
    }

    while(1)
    {
        GPSDataRead();
        GPSSentenceParse();
        ClutchHold(); //This function handles the venting direction of the clutch actuator
        DataFlagFunc(); //This function handles the updates of the data flag variable
        //USB stack process function
        USBTasks();

        switch(state){
            case wait:
                USBTasks();
                millisec = 0;
                if(CheckLogStateChange() == 1){ //start the transition from wait to log
                    state = startLog;
                }
                break;
            case startLog:
                //if thumbdrive is plugged in
                if(USBHostMSDSCSIMediaDetect())
                {
                    deviceAttached = TRUE;
                    //now a device is attached
                    //See if the device is attached and in the right format
                    if(FSInit())
                    {
                        //Opening a file in mode "w" will create the file if it doesn't
                        //  exist.  If the file does exist it will delete the old file
                        //  and create a new one that is blank.
                        logNum = readEEPROM(addy);
                        sprintf(nameString, "test%d.csv", logNum);
                        myFile = FSfopen(nameString,"w");
                        FSfwrite(GroupString,1,strlen(GroupString),myFile);
                        FSfwrite(UnitString,1,strlen(UnitString),myFile);
                        FSfwrite(ParamString,1, strlen(ParamString),myFile);
                        millisec = 0;
                        //LATDSET = 0x4000; //Send sync pulse (aeroprobe)
                       // while(millisec < 1000){} //Wait 1s then move to log, the aeroprobe ADC waits 1s.
                            state = log;
                        LATECLR = 0x200; //Turn on Green
                        LATASET = 0x10; //Turn off Red
                    }
                }
                break;
            case log:
                //This uses MOTEC as the master timer.  Data is only written to the USB after all the motec Data is received
                if(motec0Read && motec1Read && motec2Read && motec3Read && motec4Read && motec5Read){
                    WriteToUSB();
                }
                else{}//Wait for motec data to write the next row
                if(CheckLogStateChange() == 2){ //Start the transition from log to wait
                    state = stopLog;
                }
                if(millisec > 2000){
                    LATDCLR = 0x4000; //After 2 seconds pass no need to keep output high
                }
                //Add a function to check for a flag button and set a variable
                break;
            case stopLog:
                //Always make sure to close the file so that the data gets written to the drive.
                FSfwrite("endFile", 1, 7, myFile);
                FSfclose(myFile);
                state = wait;
                logNum++;
                writeEEPROM(addy, logNum);
                LATACLR = 0x10; //Turn on Red
                LATESET = 0x200; //Turn off Green
                break;
            default:
                state = wait;
                break;
        }


        //CAN Handlers
        CANRxMessageBuffer* CAN1RxMessage = CAN1RxMsgProcess();
        if(CAN1RxMessage){
            WriteAccelData(CAN1RxMessage); //Accel is on CAN 1
        }
        CANRxMessageBuffer* CAN2RxMessage = CAN2RxMsgProcess();
        if(CAN2RxMessage){
            writeCan2Msg(CAN2RxMessage); //Motec is on CAN 2
        }
    }
    return 0;
}
Exemple #19
0
//******************************************************************************
//******************************************************************************
// Main
//******************************************************************************
//******************************************************************************
int main (void)
{
	BYTE i;
	DWORD temp;

	int  value;

	value = SYSTEMConfigWaitStatesAndPB( GetSystemClock() );

	mJTAGPortEnable(DEBUG_JTAGPORT_OFF);

	// Enable the cache for the best performance
	CheKseg0CacheOn();

	value = OSCCON;
	while (!(value & 0x00000020))
	{
		value = OSCCON;    // Wait for PLL lock to stabilize
	}

	InitKeyboardDriver();

	INTEnableSystemMultiVectoredInt();

	// Init status LED
	mPORTCSetBits(BIT_0);
	mPORTCSetPinsDigitalOut(BIT_0);

	//DBINIT();

	// Initialize USB layers
	USBInitialize(0);

	while (1)
	{
		USBTasks();
		App_Detect_Device();
		switch (App_State_Keyboard)
		{
			case DEVICE_NOT_CONNECTED:
				mPORTCSetBits(BIT_0);
				USBTasks();
				if (DisplayDeatachOnce == FALSE)
				{
					DBPRINTF("Device Detached\n");
					DisplayDeatachOnce = TRUE;
				}
				if (USBHostHID_ApiDeviceDetect()) /* True if report descriptor is parsed with no error */
				{
					DBPRINTF("Device Attached\n");
					App_State_Keyboard = DEVICE_CONNECTED;
					DisplayConnectOnce = FALSE;
				}
				break;
			case DEVICE_CONNECTED:
				mPORTCClearBits(BIT_0);
				App_State_Keyboard = READY_TO_TX_RX_REPORT;
				if (DisplayConnectOnce == FALSE)
				{
					DisplayConnectOnce = TRUE;
					DisplayDeatachOnce = FALSE;
				}
				InitializeTimer(); // start 10ms timer to schedule input reports

				break;
			case READY_TO_TX_RX_REPORT:
				if (!USBHostHID_ApiDeviceDetect())
				{
					App_State_Keyboard = DEVICE_NOT_CONNECTED;
					//                                DisplayOnce = FALSE;
				}
				break;
			case GET_INPUT_REPORT:
				if (USBHostHID_ApiGetReport(Appl_raw_report_buffer.Report_ID, Appl_ModifierKeysDetails.interfaceNum,
																		Appl_raw_report_buffer.ReportSize, Appl_raw_report_buffer.ReportData))
				{
					/* Host may be busy/error -- keep trying */
				}
				else
				{
					App_State_Keyboard = INPUT_REPORT_PENDING;
				}
				USBTasks();
				break;
			case INPUT_REPORT_PENDING:
				if (USBHostHID_ApiTransferIsComplete(&ErrorDriver, &NumOfBytesRcvd))
				{
					if (ErrorDriver || (NumOfBytesRcvd !=     Appl_raw_report_buffer.ReportSize ))
					{
						ErrorCounter++ ;
						if (MAX_ERROR_COUNTER <= ErrorDriver)
							App_State_Keyboard = ERROR_REPORTED;
						else
							App_State_Keyboard = READY_TO_TX_RX_REPORT;
					}
					else
					{
						ErrorCounter = 0;
						ReportBufferUpdated = TRUE;
						App_State_Keyboard = READY_TO_TX_RX_REPORT;

						if (DisplayConnectOnce == TRUE)
						{
							for (i = 0; i < Appl_raw_report_buffer.ReportSize; i++)
							{
								if (Appl_raw_report_buffer.ReportData[i] != 0)
								{
									//LCDClear();
									//LCDL1Home();
									DisplayConnectOnce = FALSE;
								}
							}
						}

						App_ProcessInputReport();
						App_PrepareOutputReport();
					}
				}
				break;

			case SEND_OUTPUT_REPORT: /* Will be done while implementing Keyboard */
				if (USBHostHID_ApiSendReport(Appl_LED_Indicator.reportID, Appl_LED_Indicator.interfaceNum, Appl_LED_Indicator.reportLength,
																		(BYTE*) & Appl_led_report_buffer))
				{
					/* Host may be busy/error -- keep trying */
				}
				else
				{
					App_State_Keyboard = OUTPUT_REPORT_PENDING;
				}
				USBTasks();

				break;
			case OUTPUT_REPORT_PENDING:
				if (USBHostHID_ApiTransferIsComplete(&ErrorDriver, &NumOfBytesRcvd))
				{
					if (ErrorDriver)
					{
						ErrorCounter++ ;
						if (MAX_ERROR_COUNTER <= ErrorDriver)
							App_State_Keyboard = ERROR_REPORTED;

						//                                App_State_Keyboard = READY_TO_TX_RX_REPORT;
					}
					else
					{
						ErrorCounter = 0;
						App_State_Keyboard = READY_TO_TX_RX_REPORT;
					}
				}
				break;

			case ERROR_REPORTED:
				break;
			default:
				break;
		}
	}
}