コード例 #1
0
ファイル: main.c プロジェクト: Athuli7/Microchip
int main ( void )
{
    // Initialize the processor and peripherals.
    if ( InitializeSystem() != TRUE )
    {
        UART2PrintString( "\r\n\r\nCould not initialize USB Custom Demo App - system.  Halting.\r\n\r\n" );
        while (1);
    }
    if ( USBHostInit(0) == TRUE )
    {
        UART2PrintString( "\r\n\r\n***** USB Custom Demo App Initialized *****\r\n\r\n" );
    }
    else
    {
        UART2PrintString( "\r\n\r\nCould not initialize USB Custom Demo App - USB.  Halting.\r\n\r\n" );
        while (1);
    }

    // Main Processing Loop
    while (1)
    {
        // This demo does not check for overcurrent conditions.  See the
        // USB Host - Data Logger for an example of overcurrent detection
        // with the PIC24F and the USB PICtail Plus.

        // Maintain USB Host State
        USBHostTasks();
        // Maintain Demo Application State
        ManageDemoState();
    }

    return 0;

} // main
コード例 #2
0
BOOL USBHostChargerEventHandler( BYTE address, USB_EVENT event, void *data, DWORD size )
{
    // Make sure the event is for a connected device
    if (!_USBHostCharger_FindDevice( address ))
    {
        return FALSE;
    }

    // Handle specific events.
    switch (event)
    {
        case EVENT_DETACH:
            // Notify that application that the device has been detached.
            USB_HOST_APP_EVENT_HANDLER(usbChargingDevices[currentChargingRecord].ID.deviceAddress, EVENT_CHARGER_DETACH, &usbChargingDevices[currentChargingRecord].ID.deviceAddress, sizeof(BYTE) );
            usbChargingDevices[currentChargingRecord].flags.val        = 0;
            usbChargingDevices[currentChargingRecord].ID.deviceAddress = 0;
            #ifdef DEBUG_MODE
                UART2PrintString( "USB Charging Client Device Detached: address=" );
                UART2PutDec( address );
                UART2PrintString( "\r\n" );
            #endif
            return TRUE;
            break;

        case EVENT_SUSPEND:
        case EVENT_RESUME:
        case EVENT_BUS_ERROR:
        default:
            break;
    }

    return FALSE;
} // USBHostChargerEventHandler
コード例 #3
0
ファイル: main.c プロジェクト: 21rcc/ioio
int main() {
  ADB_FILE_HANDLE f;
  iPPSInput(IN_FN_PPS_U2RX,IN_PIN_PPS_RP2);       //Assign U2RX to pin RP2 (42)
  iPPSOutput(OUT_PIN_PPS_RP4,OUT_FN_PPS_U2TX);    //Assign U2TX to pin RP4 (43)
  UART2Init();

  UART2PrintString("***** Hello from app! *******\r\n");

  f = ADBFileRead("/data/data/ioio.manager/files/image.ioio", &FileCallback);
  UART2PrintString("***** file handle: ");
  UART2PutHexWord(f);
  UART2PrintString("*****\r\n");

  state = STATE_READ_FILE;
  
  while (state == STATE_READ_FILE) {
    BootloaderTasks();
  }
  

  // blink LED
  TRISFbits.TRISF3 = 0;
  while (1) {
    long i = 1000L;
    LATFbits.LATF3 = 0;
    while (i--);
    i = 1000000L;
    LATFbits.LATF3 = 1;
    while (i--);
    BootloaderTasks();
  }
}
コード例 #4
0
ファイル: main.c プロジェクト: Athuli7/Microchip
BOOL CheckForNewAttach ( void )
{
    // Try to get the device address, if we don't have one.
    if (deviceAddress == 0)
    {
        GENERIC_DEVICE_ID DevID;

        DevID.vid   = 0x04D8;
        DevID.pid   = 0x000C;
        #ifdef USB_GENERIC_SUPPORT_SERIAL_NUMBERS
            DevID.serialNumberLength = 0;
            DevID.serialNumber = NULL;
        #endif

        if (USBHostGenericGetDeviceAddress(&DevID))
        {
            deviceAddress = DevID.deviceAddress;
            UART2PrintString( "Generic demo device attached - polled, deviceAddress=" );
            UART2PutDec( deviceAddress );
            UART2PrintString( "\r\n" );
            return TRUE;
        }
    }

    return FALSE;

} // CheckForNewAttach
コード例 #5
0
void MonitorVBUS( void )
{
    #if defined( __PIC24FJ256GB110__)
        if (AD1CON1bits.DONE)
        {
            if (ADC_READING_VBUS < OVERCURRENT_TRIP_READING)
            {
                USBHostVbusEvent( EVENT_VBUS_OVERCURRENT, USB_ROOT_HUB, 0 );
                if (!status.overcurrentStateUSB)
                {
                    UART2PrintString( "\r\n***** USB Error - overcurrent detected *****\r\n" );
                    status.overcurrentStateUSB = TRUE;
                }
            }
            else if (ADC_READING_VBUS > OVERCURRENT_RESET_READING)
            {
                if (status.overcurrentStateUSB)
                {
                    USBHostVbusEvent( EVENT_VBUS_POWER_AVAILABLE, USB_ROOT_HUB, 0 );
                    UART2PrintString( "\r\n***** USB overcurrent condition removed *****\r\n" );
                }
                status.overcurrentStateUSB = FALSE;
            }
            AD1CON1     = 0x80E4;       // Start the next conversion.
        }
    #endif
}
コード例 #6
0
BYTE USBHostBlukWrite( BYTE deviceAddress, void *buffer, DWORD length )
{
    BYTE RetVal;
    DWORD i;

    // Validate the call
    if ((g_usbbt.initialized != 1) ||
            (g_usbbt.deviceAddress != deviceAddress)) return USB_INVALID_STATE;
    if (g_usbbt.endpointBulkOUT_Busy)	return USB_BUSY;

    UART2PrintString( "USBHostBlukWrite\r\n" );
    for(i = 0; i < length; i++)
    {
        UART2PutHex(*((char*)buffer+i));
    }
    UART2PrintString( "\r\n" );
    // Set the busy flag and start a new OUT transfer.
    g_usbbt.endpointBulkOUT_Busy = 1;
    RetVal = USBHostWrite( deviceAddress, g_usbbt.endpointBulkOUT, (BYTE *)buffer, length );
    if (RetVal != USB_SUCCESS)
    {
        g_usbbt.endpointBulkOUT_Busy = 0;	 // Clear flag to allow re-try
    }

    return RetVal;

}
コード例 #7
0
ファイル: main.c プロジェクト: nakakure/CUI32USBCamera
BOOL InitializeSystem ( void )
{

    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
    }

    // Init UART
    UART2Init();
    // Set Default demo state
    DemoState = DEMO_INITIALIZE;
	if(USBHostIsochronousBuffersCreate(&isocData,2,1024)){
    	UART2PrintString( "CreateIsochronousBuffers\r\n" );
	}else{
        UART2PrintString( "Fail:CreateIsochronousBuffers\r\n" );
	}

    return TRUE;
} // InitializeSystem
コード例 #8
0
BYTE USBHostCtrlWrite( BYTE deviceAddress, void *buffer, DWORD length )
{
    BYTE RetVal;
    DWORD i;

    // Validate the call
    if ((g_usbbt.initialized != 1) ||
            (g_usbbt.deviceAddress != deviceAddress)) return USB_INVALID_STATE;
    if (g_usbbt.endpointCtrl_Busy)	 return USB_BUSY;

    UART2PrintString( "USBHostCtrlWrite\r\n" );
    for(i = 0; i < length; i++)
    {
        UART2PutHex(*((char*)buffer+i));
    }
    UART2PrintString( "\r\n" );
    g_usbbt.endpointCtrl_Busy = 1;
    RetVal = USBHostIssueDeviceRequest( deviceAddress,
                                        USB_SETUP_HOST_TO_DEVICE|USB_SETUP_TYPE_CLASS,
                                        0, 0, 0,
                                        length, buffer,
                                        USB_DEVICE_REQUEST_SET,
                                        g_usbbt.clientDriverID);
    if (RetVal != USB_SUCCESS)
    {
        g_usbbt.endpointCtrl_Busy = 0;
    }

    return RetVal;
}
コード例 #9
0
ファイル: main.c プロジェクト: Masa55/BT_DROID
void bt_init ( void )
{
	sys_init();
	mem_init();
	memp_init();
	pbuf_init();
	UART2PrintString("mem mgmt initialized\r\n");
	lwbt_memp_init();

	phybusif_init("");

	cb = malloc(sizeof(struct phybusif_cb));
	phybusif_reset(cb);

	if(hci_init() != ERR_OK) {
		UART2PrintString("HCI initialization failed!\r\n");
		return;
	}
	l2cap_init();
	sdp_init();
	rfcomm_init();
	UART2PrintString("Bluetooth initialized.\r\n");

	bt_spp_start();
	UART2PrintString("Applications started.\r\n");
}
コード例 #10
0
ファイル: main.c プロジェクト: Athuli7/Microchip
BOOL ValidateAndDisplayDeviceFwVersion ( void )
{
    if ( USBHostGenericGetRxLength(deviceAddress) == 4             &&
         DataPacket.CMD                   == READ_VERSION          &&
         DataPacket._byte[3]              >= DEMO_FW_MAJOR_VERSION    )
    {
        // Display Device FW version on LCD
        LcdData[0][13] = '0' + DataPacket._byte[3];
        LcdData[0][15] = '0' + DataPacket._byte[4];
        LCDWriteLine(1, (char *)&LcdData[0][0] );

        // Display device FW version on terminal
        UART2PrintString( "Device firmware version " );
        UART2PutDec( DataPacket._byte[3] );
        UART2PrintString( "." );
        UART2PutDec( DataPacket._byte[4] );
        UART2PrintString( "\r\n" );

        return TRUE;
    }
    else
    {
        UART2PrintString( "Device Firmware Version Error!\r\n" );
        LCDWriteLine( 2, "Dev FW Ver Error" );
        return FALSE;
    }

} // ValidateAndDisplayDeviceFwVersion
コード例 #11
0
ファイル: main.c プロジェクト: nakakure/CUI32USBCamera
void packet_dump(BYTE* data,long size){
	long j;
    UART2PrintString( "DATA=" );
	for(j = 0;j < size;j++){
          	UART2PutHex(data[j]);
    		UART2PrintString( " " );
	}
    UART2PrintString( "\r\n" );
}
コード例 #12
0
ファイル: main.c プロジェクト: Masa55/BT_DROID
int main ( void )
{
    // Initialize the processor and peripherals.
    if ( InitializeSystem() != TRUE )
    {
        UART2PrintString( "\r\n\r\nCould not initialize USB Custom Demo App - system.  Halting.\r\n\r\n" );
        while (1);
    }
    if ( USBHostInit(0) == TRUE )
    {
        UART2PrintString( "\r\n\r\n***** USB Custom Demo App Initialized *****\r\n\r\n" );
    }
    else
    {
        UART2PrintString( "\r\n\r\nCould not initialize USB Custom Demo App - USB.  Halting.\r\n\r\n" );
        while (1);
    }

	btClientData.State = BT_STATE_IDLE;
	btClientData.Initialized = FALSE;

	mPORTAOutputConfig(0x3);

	mPORTAWrite(0x0);

	mPORTBOutputConfig(0x10);

	// OC 1
	PPSOutput(PPS_RP4, PPS_OC1);

	//Enable Interrupt
	SetPriorityIntOC1(4);
	EnableIntOC1;

	OpenTimer2(T2_ON | T2_PS_1_8 ,0xffff); // 
	OpenOC1(OC_IDLE_CON | OC_TIMER2_SRC | OC_PWM_EDGE_ALIGN ,OC_SYNC_TRIG_IN_TMR2,0,0);

	SetDCOC1PWM(0xc00,0);

    // Main Processing Loop
    while (1)
    {
        BTClientTasks();

        // Maintain USB Host State
        USBHostTasks();

		DelayMs(1);
    }

    return 0;

} // main
コード例 #13
0
ファイル: hidmain.c プロジェクト: Nikolay-Kha/CNCMachine
/****************************************************************************
  Function:
    void App_ProcessInputReport_Mouse(void)

  Description:
    This function processes input report received from HID Mouse device.

  Precondition:
    None

  Parameters:
    None

  Return Values:
    None

  Remarks:
    None
***************************************************************************/
void App_ProcessInputReport_Mouse(void)
{
   /* process input report received from device */
    USBHostHID_ApiImportData(Appl_raw_report_buffer.ReportData, Appl_raw_report_buffer.ReportSize
                          ,Appl_Button_report_buffer, &Appl_Mouse_Buttons_Details);
    USBHostHID_ApiImportData(Appl_raw_report_buffer.ReportData, Appl_raw_report_buffer.ReportSize
                          ,Appl_XY_report_buffer, &Appl_XY_Axis_Details);

    {
        unsigned int i;

        UART2PrintString( "\r\n" );
        UART2PrintString( UHP_MOUSE_REPORT );
        for(i=0;i<(Appl_raw_report_buffer.ReportSize);i++)
        {
            if(i!=0) UART2PrintString( "-" );
            UART2PutHex( Appl_raw_report_buffer.ReportData[i]);
        }
        UART2PrintString( "\r\n" );
//        UART2PrintString( "\r\n  Left Bt :  " ); UART2PutHex( Appl_Button_report_buffer[0]);
//        UART2PrintString( "\r\n  Right Bt :  " ); UART2PutHex( Appl_Button_report_buffer[1]);
//
//        UART2PrintString( "\r\n  X-Axis :  " ); UART2PutHex( Appl_XY_report_buffer[0]);
//        UART2PrintString( "\r\n  Y-Axis :  " ); UART2PutHex( Appl_XY_report_buffer[1]);

        if(Appl_Button_report_buffer[0] == 0x01)
        {
                // Turn on Left Button, Green LED, D1
                TRISBbits.TRISB12 = 0;
                _RB12=0;
        }
        else
        {
                // Turn off Left Button, Green LED, D1
                TRISBbits.TRISB12 = 1;
        }

        if(Appl_Button_report_buffer[1] == 0x01)
        {
                // Turn on Left Button, Green LED, D1
                TRISBbits.TRISB14 = 0;
                _RB14=0;
        }
        else
        {
                // Turn off Left Button, Green LED, D1
                TRISBbits.TRISB14 = 1;
        }

    }

}
コード例 #14
0
ファイル: main.c プロジェクト: 21rcc/ioio
void FileCallback(ADB_FILE_HANDLE f, const void* data, UINT32 data_len) {
  if (data) {
    UINT32 i;
    UART2PrintString("***** Got file data *******\r\n");
    for (i = 0; i < data_len; ++i) {
      UART2PutHex(((const BYTE*) data)[i]);
      UART2PutChar(' ');
    }
  } else {
    if (data_len == 0) {
       UART2PrintString("***** EOF *******\r\n");
    } else {
       UART2PrintString("***** Error *******\r\n");
    }
    state = STATE_DONE;
  }
}
コード例 #15
0
ファイル: MainDemo.c プロジェクト: OptecInc/FocusLynx_FW
 void __attribute__((interrupt, auto_psv)) _DefaultInterrupt(void)
 {
   UART2PrintString( "!!! Default interrupt handler !!!\r\n" );
   while (1)
   {
       Nop();
       Nop();
       Nop();
   }
 }
コード例 #16
0
ファイル: MainDemo.c プロジェクト: OptecInc/FocusLynx_FW
 void __attribute__((interrupt, auto_psv)) _OscillatorFail(void)
 {
   UART2PrintString( "!!! Oscillator Fail interrupt handler !!!\r\n" );
   while (1)
   {
       Nop();
       Nop();
       Nop();
   }
 }
コード例 #17
0
ファイル: MainDemo.c プロジェクト: OptecInc/FocusLynx_FW
 void __attribute__((interrupt, auto_psv)) _MathError(void)
 {
   UART2PrintString( "!!! Math Error interrupt handler !!!\r\n" );
   while (1)
   {
       Nop();
       Nop();
       Nop();
   }
 }
コード例 #18
0
ファイル: main.c プロジェクト: nakakure/CUI32USBCamera
int main ( void )
{
    if ( InitializeSystem() != TRUE )
    {
        UART2PrintString( "\r\n\r\nCould not initialize USB Custom Demo App - system.  Halting.\r\n\r\n" );
        while (1);
    }
    if ( USBHostInit(0) == TRUE )
    {
        UART2PrintString( "\r\n\r\n***** USB Custom Demo App Initialized *****\r\n\r\n" );
    }
    else
    {
        UART2PrintString( "\r\n\r\nCould not initialize USB Custom Demo App - USB.  Halting.\r\n\r\n" );
        while (1);
    }
    while (1)
    {
        USBHostTasks();
        ManageDemoState();
    }
    return 0;
} // main
コード例 #19
0
ファイル: app_host_bridge.c プロジェクト: timwuu/PK3SP24
/****************************************************************************
  Function:
    BOOL USB_HID_DataCollectionHandler(void)
  Description:
    This function is invoked by HID client , purpose is to collect the
    details extracted from the report descriptor. HID client will store
    information extracted from the report descriptor in data structures.
    Application needs to create object for each report type it needs to
    extract.
    For ex: HID_DATA_DETAILS pickit.keys.modifier.details;
    HID_DATA_DETAILS is defined in file usb_host_hid_appl_interface.h
    Each member of the structure must be initialized inside this function.
    Application interface layer provides functions :
    USBHostHID_ApiFindBit()
    USBHostHID_ApiFindValue()
    These functions can be used to fill in the details as shown in the demo
    code.

  Precondition:
    None

  Parameters:
    None

  Return Values:
    true    - If the report details are collected successfully.
    false   - If the application does not find the the supported format.

  Remarks:
    This Function name should be entered in the USB configuration tool
    in the field "Parsed Data Collection handler".
    If the application does not define this function , then HID cient
    assumes that Application is aware of report format of the attached
    device.
 ***************************************************************************/
bool APP_HostHIDKeyboardReportParser(void) {
    uint8_t NumOfReportItem = 0;
    uint8_t i;
    USB_HID_ITEM_LIST* pitemListPtrs;
    USB_HID_DEVICE_RPT_INFO* pDeviceRptinfo;
    HID_REPORTITEM *reportItem;
    HID_USAGEITEM *hidUsageItem;
    //uint8_t usageIndex;
   // uint8_t reportIndex;
   // uint8_t usageItem;
    
    /* The pickit is already in use. */
    if (pickit.inUse == true) {

        //PRINT_String( "-In Use-\r\n",10);
        return false;
    }

    pDeviceRptinfo = USBHostHID_GetCurrentReportInfo(); // Get current Report Info pointer
    pitemListPtrs = USBHostHID_GetItemListPointers(); // Get pointer to list of item pointers

    /* Find Report Item Index for Modifier Keys */
    /* Once report Item is located , extract information from data structures provided by the parser */
    NumOfReportItem = pDeviceRptinfo->reportItems;

#ifdef DEBUG_MODE
    UART2PrintString("APP: NumOfReportItem:");
    UART2PutHex(NumOfReportItem);
    UART2PutChar('\n');

    USBHID_ReportDecriptor_Dump();
#endif
    
    reportItem = &pitemListPtrs->reportItemList[0];
    
    pickit.details.reportLength = 64; // (pitemListPtrs->reportList[reportIndex].inputBits + 7) / 8;
    pickit.details.reportID = (uint8_t) reportItem->globals.reportID;
    pickit.details.bitOffset = (uint8_t) reportItem->startBit;
    pickit.details.bitLength = (uint8_t) reportItem->globals.reportsize;
    pickit.details.count = (uint8_t) reportItem->globals.reportCount;
    pickit.details.interfaceNum = USBHostHID_ApiGetCurrentInterfaceNum();

    pickit.size = 64;
    pickit.buffer = (uint8_t*) malloc(pickit.size);
    pickit.inUse = true;

    return (pickit.inUse);
}
コード例 #20
0
BOOL USBHostChargerInitialize( BYTE address, DWORD flags, BYTE clientDriverID )
{
    BYTE    *pDesc;

    // Find a new entry
    for (currentChargingRecord=0; currentChargingRecord<USB_MAX_CHARGING_DEVICES; currentChargingRecord++)
    {
        if (!usbChargingDevices[currentChargingRecord].flags.inUse) break;
    }
    if (currentChargingRecord == USB_MAX_CHARGING_DEVICES)
    {
        #ifdef DEBUG_MODE
            UART2PrintString( "CHG: No more space\r\n" );
        #endif
        return FALSE;   // We have no more room for a new device.
    }

    // Initialize state - set the inUse flag.
    usbChargingDevices[currentChargingRecord].flags.val = 1;

    // Save device the address, VID, & PID
    usbChargingDevices[currentChargingRecord].ID.deviceAddress = address;
    usbChargingDevices[currentChargingRecord].ID.clientDriverID = clientDriverID;
    pDesc  = USBHostGetDeviceDescriptor(address);
    pDesc += 8;
    usbChargingDevices[currentChargingRecord].ID.vid  =  (WORD)*pDesc;       pDesc++;
    usbChargingDevices[currentChargingRecord].ID.vid |= ((WORD)*pDesc) << 8; pDesc++;
    usbChargingDevices[currentChargingRecord].ID.pid  =  (WORD)*pDesc;       pDesc++;
    usbChargingDevices[currentChargingRecord].ID.pid |= ((WORD)*pDesc) << 8; pDesc++;

    VID = usbChargingDevices[currentChargingRecord].ID.vid;
    PID = usbChargingDevices[currentChargingRecord].ID.pid;

    // Notify that application that we've been attached to a device.
    USB_HOST_APP_EVENT_HANDLER(address, EVENT_CHARGER_ATTACH,
            &(usbChargingDevices[currentChargingRecord].ID), sizeof(USB_CHARGING_DEVICE_ID) );

    return TRUE;

} // USBHostChargerInit
コード例 #21
0
ファイル: hidmain.c プロジェクト: Nikolay-Kha/CNCMachine
void App_ProcessInputReport_Keyboard(void)
{
    BYTE  i;
    BYTE  j;
   /* process input report received from device */
    USBHostHID_ApiImportData(Appl_raw_report_buffer.ReportData, Appl_raw_report_buffer.ReportSize
                          ,Appl_BufferModifierKeys, &Appl_ModifierKeysDetails);
    USBHostHID_ApiImportData(Appl_raw_report_buffer.ReportData, Appl_raw_report_buffer.ReportSize
                          ,Appl_BufferNormalKeys, &Appl_NormalKeysDetails);

    BOOL before = TRUE;
    BOOL csnLock = FALSE;
    BOOL allZero = TRUE;
    for(i=0;i<(sizeof(Appl_BufferNormalKeys)/sizeof(Appl_BufferNormalKeys[0]));i++)
    {
        if(Appl_BufferNormalKeys[i])
            allZero = FALSE;
        if(!App_CompareKeyPressedPrevBuf(Appl_BufferNormalKeys[i]))  {
            before = FALSE;
            if(Appl_BufferNormalKeys[i] == HID_CAPS_LOCK_VAL)
            {
               CAPS_Lock_Pressed = !CAPS_Lock_Pressed;
               LED_Key_Pressed = csnLock = TRUE;
               Appl_led_report_buffer.CAPS_LOCK = CAPS_Lock_Pressed;
            }else if(Appl_BufferNormalKeys[i] == HID_NUM_LOCK_VAL)
            {
                NUM_Lock_Pressed = !NUM_Lock_Pressed;
                LED_Key_Pressed = csnLock = TRUE;
                Appl_led_report_buffer.NUM_LOCK = NUM_Lock_Pressed;
            }else if(Appl_BufferNormalKeys[i] == HID_SCROLL_LOCK_VAL)
            {
                SCROLL_Lock_Pressed = !SCROLL_Lock_Pressed;
                LED_Key_Pressed = csnLock = TRUE;
                Appl_led_report_buffer.SCROLL_LOCK = SCROLL_Lock_Pressed;
            }
        }
    }
    if(allZero && allZero!=lastAllZero)
        before = FALSE;
    lastAllZero = allZero;
    
    if(!csnLock) {
        if(before && KeyRepeatCounter<=REPEAT_COUNT)
            KeyRepeatCounter++;
        if(!before || KeyRepeatCounter>REPEAT_COUNT) {
        /* check if key press was present in previous report */
        // if key press was pressed in previous report neglect it ????
            UART2PrintString( "\r\n" );
            UART2PrintString( UHP_KEYBOARD_REPORT );
            for(j=0;j<(Appl_raw_report_buffer.ReportSize);j++)
            {
                if(j!=0) UART2PrintString( "-" );
                if(j==0 && CAPS_Lock_Pressed)
                    UART2PutHex( Appl_raw_report_buffer.ReportData[j] ^ 0x02);
                else
                    UART2PutHex( Appl_raw_report_buffer.ReportData[j]);
            }
            UART2PrintString( "\r\n" );
            //data = App_HID2ASCII(Appl_BufferNormalKeys[i]);  // convert data to ascii
            //UART2PutChar(data);
        }
    }
    if(!before)
        KeyRepeatCounter = 0;
  App_CopyToShadowBuffer();
  App_Clear_Data_Buffer();
}
コード例 #22
0
ファイル: hidmain.c プロジェクト: Nikolay-Kha/CNCMachine
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;

    }
}
コード例 #23
0
ファイル: main.c プロジェクト: nakakure/CUI32USBCamera
BOOL USB_ApplicationEventHandler ( BYTE address, USB_EVENT event, void *data, DWORD size )
{
	static int aaa = 0;
	static long data_cnt = 0;
	static long data_cnt_bak = 0;
	static long jpeg_cnt = 0;
	static long jpeg_size = 0;
	static long jpeg_size_bak = 0;
	static long jpeg_ptr = 0;
	static long jpeg_start = 0;
    #ifdef USB_GENERIC_SUPPORT_SERIAL_NUMBERS
        BYTE i;
    #endif
	int j;
    // Handle specific events.
    switch ( (INT)event )
    {
        case EVENT_TRANSFER:         // A USB transfer has completed
		case EVENT_DATA_ISOC_READ:
			for(j = 0;j < size-1;j++){
				if(((BYTE*)data)[j] == 0xFF){
						if(((BYTE*)data)[j+1] == 0xD8){
							if(((BYTE*)data)[j+2] == 0xFF){
							if(((BYTE*)data)[j+3] == 0xE0){
								jpeg_size = data_cnt -jpeg_size_bak;
								jpeg_size_bak = data_cnt;
		            			/*UART2PrintString( "JPEG-SIZE=" );
								UART2PutDec((jpeg_size/100000) % 10);
								UART2PutDec((jpeg_size/10000) % 10);
								UART2PutDec((jpeg_size/1000) % 10);
								UART2PutDec((jpeg_size/100) % 10);
								UART2PutDec((jpeg_size/10) % 10);
								UART2PutDec(jpeg_size % 10);
		            			UART2PrintString( "JPEG-CNT=" );
								UART2PutDec((jpeg_cnt/1000) % 10);
								UART2PutDec((jpeg_cnt/100) % 10);
								UART2PutDec((jpeg_cnt/10) % 10);
								UART2PutDec(jpeg_cnt % 10);
		            			UART2PrintString( "\r\n" );*/
								if(jpeg_cnt == 1){
			            			UART2PrintString( "JPEG-SIZE=" );
									UART2PutDec((jpeg_ptr/100000) % 10);
									UART2PutDec((jpeg_ptr/10000) % 10);
									UART2PutDec((jpeg_ptr/1000) % 10);
									UART2PutDec((jpeg_ptr/100) % 10);
									UART2PutDec((jpeg_ptr/10) % 10);
									UART2PutDec(jpeg_ptr % 10);
		            				UART2PrintString( "\r\n" );
									packet_dump(jpeg,jpeg_ptr);
								}
								jpeg_cnt++;
								jpeg_start = j;
								//packet_dump((data + j),4);
							}
							
							}
						}
					}
			}
			if((size != 0x0C) && jpeg_cnt == 1){
				int i;
				for(i = 0x0C;i < size;i++){
					if(jpeg_ptr == 0){
            			UART2PrintString( "jpeg_start=" );
						i = jpeg_start;
						UART2PutDec(jpeg_cnt % 10);
            			UART2PrintString( "\r\n" );
					}
					jpeg[jpeg_ptr++] = ((BYTE*)data)[i];
				}
			}
			if(size != 0x0C){
			/*if(aaa >= 0 && aaa <= 0){
	            UART2PrintString( "DATA=" );
				packet_dump(data,size);
	            UART2PrintString( "\r\n ");
				aaa++;
			}*/
			}
			data_cnt += size;
			/*if(data_cnt > data_cnt_bak + 1024 * 10){
				//data_cnt = 1024 * 100;
	            UART2PrintString( "a" );
				UART2PutDec((data_cnt/1000000) % 10);
				UART2PutDec((data_cnt/100000) % 10);
				UART2PutDec((data_cnt/10000) % 10);
				UART2PutDec((data_cnt/1000) % 10);
				UART2PutDec((data_cnt/100) % 10);
				UART2PutDec((data_cnt/10) % 10);
				UART2PutDec(data_cnt % 10);
	            UART2PrintString( "\r\n" );
				data_cnt_bak = data_cnt;
			}*/

            return TRUE;
			break;
            UART2PrintString( "a" );
        case EVENT_GENERIC_ATTACH:
            return TRUE;
            break;

        case EVENT_GENERIC_DETACH:
            deviceAddress   = 0;
            DemoState = DEMO_INITIALIZE;
            UART2PrintString( "Generic demo device detached - event\r\n" );
            return TRUE;

        case EVENT_GENERIC_TX_DONE:           // The main state machine will poll the driver.
        case EVENT_GENERIC_RX_DONE:
            return TRUE;

        case EVENT_VBUS_REQUEST_POWER:
            // We'll let anything attach.
            return TRUE;

        case EVENT_VBUS_RELEASE_POWER:
            // We aren't keeping track of power.
            return TRUE;

        case EVENT_HUB_ATTACH:
            UART2PrintString( "\r\n***** USB Error - hubs are not supported *****\r\n" );
            return TRUE;
            break;

        case EVENT_UNSUPPORTED_DEVICE:
            UART2PrintString( "\r\n***** USB Error - device is not supported *****\r\n" );
            return TRUE;
            break;

        case EVENT_CANNOT_ENUMERATE:
            UART2PrintString( "\r\n***** USB Error - cannot enumerate device *****\r\n" );
            return TRUE;
            break;

        case EVENT_CLIENT_INIT_ERROR:
            UART2PrintString( "\r\n***** USB Error - client driver initialization error *****\r\n" );
            return TRUE;
            break;

        case EVENT_OUT_OF_MEMORY:
            UART2PrintString( "\r\n***** USB Error - out of heap memory *****\r\n" );
            return TRUE;
            break;

        case EVENT_UNSPECIFIED_ERROR:   // This should never be generated.
            UART2PrintString( "\r\n***** USB Error - unspecified *****\r\n" );
            return TRUE;
            break;

        case EVENT_SUSPEND:
        case EVENT_DETACH:
        case EVENT_RESUME:
        case EVENT_BUS_ERROR:
            UART2PrintString( "a" );
            return TRUE;
            break;

        default:
            break;
    }
    return FALSE;
}
コード例 #24
0
ファイル: main.c プロジェクト: nakakure/CUI32USBCamera
void ManageDemoState ( void )
{
	int j;
	DWORD   byteCount;
	BYTE    errorCode;
    BYTE RetVal;
	//接続されていなかったら初期化
    if (USBHostGenericDeviceDetached(deviceAddress) && deviceAddress != 0)
    {
		long i;
		for(i = 0;i < sizeof(jpeg);i++){
			jpeg[i] = 0;
		}
        UART2PrintString( "Generic demo device detached - polled\r\n" );
        DemoState = DEMO_INITIALIZE;
        deviceAddress   = 0;
    }
    switch (DemoState)
    {
    case DEMO_INITIALIZE:
        DemoState = DEMO_STATE_IDLE;
        break;
    case DEMO_STATE_IDLE:
		//接続されたら、読み出し処理に移行
        if (CheckForNewAttach())
        {
			DemoState = DEMO_STATE_GET_INFO;
        	UART2PrintString( "USB_Ver=" );
			UART2PutDec(((USB_DEVICE_DESCRIPTOR *)pDeviceDescriptor)->bcdUSB >> 8);
        	UART2PrintString( "-" );
			UART2PutDec(((USB_DEVICE_DESCRIPTOR *)pDeviceDescriptor)->bcdUSB);
        	UART2PrintString( "\r\n" );
        }
        break;
	case DEMO_STATE_GET_INFO:
		if(control(GET_INFO, VS_PROBE_CONTROL, 1, param, 1) == USB_SUCCESS){
        	UART2PrintString( "GET_INFO, VS_PROBE_CONTROL\r\n" );
			DemoState = DEMO_STATE_WAIT_GET_INFO;
		}
		break;
	case DEMO_STATE_WAIT_GET_INFO:
		if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
        	UART2PrintString( "OK=GET_INFO, VS_PROBE_CONTROL\r\n" );
        	UART2PrintString( "Byte Count=" );
			UART2PutDec(byteCount);
        	UART2PrintString( "\r\n" );
			packet_dump(param,byteCount);
        	UART2PrintString( "\r\n" );
			DemoState = DEMO_STATE_GET_DEF;
		}
		break;
	case DEMO_STATE_GET_DEF:
		if(control(GET_DEF, VS_PROBE_CONTROL, 1, temp, param_len) == USB_SUCCESS){
        	UART2PrintString( "GET_DEF, VS_PROBE_CONTROL\r\n" );
			DemoState = DEMO_STATE_WAIT_GET_DEF;
		}
		break;
	case DEMO_STATE_WAIT_GET_DEF:
		if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
        	UART2PrintString( "OK=GET_DEF, VS_PROBE_CONTROL\r\n" );
        	UART2PrintString( "Byte Count=" );
			UART2PutDec(byteCount);
        	UART2PrintString( "\r\n" );
			packet_dump(temp,byteCount);
        	UART2PrintString( "\r\n" );
			DemoState = DEMO_STATE_GET_MIN;
		}
		break;
	case DEMO_STATE_GET_MIN:
		if(control(GET_MIN, VS_PROBE_CONTROL, 1, temp, param_len) == USB_SUCCESS){
        	UART2PrintString( "GET_MIN, VS_PROBE_CONTROL\r\n" );
			DemoState = DEMO_STATE_WAIT_GET_MIN;
		}
		break;
	case DEMO_STATE_WAIT_GET_MIN:
		if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
        	UART2PrintString( "OK=GET_MIN, VS_PROBE_CONTROL\r\n" );
        	UART2PrintString( "Byte Count=" );
			UART2PutDec(byteCount);
        	UART2PrintString( "\r\n" );
			packet_dump(temp,byteCount);
        	UART2PrintString( "\r\n" );
			DemoState = DEMO_STATE_GET_MAX;
		}
		break;
	case DEMO_STATE_GET_MAX:
		if(control(GET_MAX, VS_PROBE_CONTROL, 1, temp, param_len) == USB_SUCCESS){
        	UART2PrintString( "GET_MAX, VS_PROBE_CONTROL\r\n" );
			DemoState = DEMO_STATE_WAIT_GET_MAX;
		}
		break;
	case DEMO_STATE_WAIT_GET_MAX:
		if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
        	UART2PrintString( "OK=GET_MAX, VS_PROBE_CONTROL\r\n" );
        	UART2PrintString( "Byte Count=" );
			UART2PutDec(byteCount);
        	UART2PrintString( "\r\n" );
			packet_dump(temp,byteCount);
        	UART2PrintString( "\r\n" );
			DemoState = DEMO_STATE_GET_CUR;
		}
		break;
	case DEMO_STATE_GET_CUR:
		if(control(GET_CUR, VS_PROBE_CONTROL, 1, temp, param_len) == USB_SUCCESS){
        	UART2PrintString( "GET_CUR, VS_PROBE_CONTROL\r\n" );
			DemoState = DEMO_STATE_WAIT_GET_CUR;
		}
		break;
	case DEMO_STATE_WAIT_GET_CUR:
		if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
        	UART2PrintString( "OK=GET_CUR, VS_PROBE_CONTROL\r\n" );
        	UART2PrintString( "Byte Count=" );
			UART2PutDec(byteCount);
        	UART2PrintString( "\r\n" );
			packet_dump(temp,byteCount);
        	UART2PrintString( "\r\n" );
			DemoState =DEMO_STATE_SET_CUR ;
		}
		break;
	case DEMO_STATE_SET_CUR:
		for(j = 0;j < param_len;j++){
			temp[j] = 0;
		}
		temp[2] = 2;//フォーマットインデックス
		temp[3] = 1;//フレームインデックス
		/*temp[4] = 0x80;
		temp[5] = 0x84;
		temp[6] = 0x1E;
		temp[7] = 0x00;*/
		temp[4] = 0x15;//30Hz
		temp[5] = 0x16;
		temp[6] = 0x05;
		temp[7] = 0x00;
		if(control(SET_CUR, VS_PROBE_CONTROL, 1, temp, param_len) == USB_SUCCESS){
        	UART2PrintString( "SET_CUR, VS_PROBE_CONTROL\r\n" );
			DemoState = DEMO_STATE_WAIT_SET_CUR;
		}
		break;
	case DEMO_STATE_WAIT_SET_CUR:
		if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
        	UART2PrintString( "OK=SET_CUR, VS_PROBE_CONTROL\r\n" );
        	UART2PrintString( "Byte Count=" );
			UART2PutDec(byteCount);
        	UART2PrintString( "\r\n" );
			packet_dump(temp,byteCount);
        	UART2PrintString( "\r\n" );
			DemoState =DEMO_STATE_GET_CUR2 ;
		}
		break;
	case DEMO_STATE_GET_CUR2:
		if(control(GET_CUR, VS_PROBE_CONTROL, 1, temp, param_len) == USB_SUCCESS){
        	UART2PrintString( "GET_CUR2, VS_PROBE_CONTROL\r\n" );
			DemoState = DEMO_STATE_WAIT_GET_CUR2;
		}
		break;
	case DEMO_STATE_WAIT_GET_CUR2:
		if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
        	UART2PrintString( "OK=GET_CUR2, VS_PROBE_CONTROL\r\n" );
        	UART2PrintString( "Byte Count=" );
			UART2PutDec(byteCount);
        	UART2PrintString( "\r\n" );
			packet_dump(temp,byteCount);
        	UART2PrintString( "\r\n" );
			DemoState =DEMO_STATE_GET_INFO2 ;
		}
		break;
	case DEMO_STATE_GET_INFO2:
		if(control(GET_INFO, VS_COMMIT_CONTROL, 1, param, 1) == USB_SUCCESS){
        	UART2PrintString( "GET_INFO, VS_COMMIT_CONTROL\r\n" );
			DemoState = DEMO_STATE_WAIT_GET_INFO2;
		}
		break;
	case DEMO_STATE_WAIT_GET_INFO2:
		if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
        	UART2PrintString( "OK=GET_INFO, VS_COMMIT_CONTROL\r\n" );
        	UART2PrintString( "Byte Count=" );
			UART2PutDec(byteCount);
        	UART2PrintString( "\r\n" );
			packet_dump(param,byteCount);
        	UART2PrintString( "\r\n" );
			DemoState = DEMO_STATE_GET_CUR3;
		}
		break;
	case DEMO_STATE_GET_CUR3:
		if(control(GET_CUR, VS_COMMIT_CONTROL, 1, temp, param_len) == USB_SUCCESS){
        	UART2PrintString( "GET_CUR2, VS_COMMIT_CONTROL\r\n" );
			DemoState = DEMO_STATE_WAIT_GET_CUR3;
		}
		break;
	case DEMO_STATE_WAIT_GET_CUR3:
		if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
        	UART2PrintString( "OK=GET_CUR2, VS_COMMIT_CONTROL\r\n" );
        	UART2PrintString( "Byte Count=" );
			UART2PutDec(byteCount);
        	UART2PrintString( "\r\n" );
			packet_dump(temp,byteCount);
        	UART2PrintString( "\r\n" );
			DemoState =DEMO_STATE_SET_CUR2 ;
		}
		break;
	case DEMO_STATE_SET_CUR2:
		for(j = 0;j < param_len;j++){
			temp[j] = 0;
		}
		temp[2] = 2;
		temp[3] = 0x01;//640x480 30Hz
		//temp[3] = 0x02;//160x120 30Hz
		//temp[3] = 0x0C;//800x600
		temp[4] = 0x80;//5Hz
		temp[5] = 0x84;
		temp[6] = 0x1E;
		temp[7] = 0x00;
		/*temp[4] = 0x15;//30Hz
		temp[5] = 0x16;
		temp[6] = 0x05;
		temp[7] = 0x00;*/
		if(control(SET_CUR, VS_COMMIT_CONTROL, 1, temp, param_len) == USB_SUCCESS){
        	UART2PrintString( "SET_CUR, VS_COMMIT_CONTROL\r\n" );
			DemoState = DEMO_STATE_WAIT_SET_CUR2;
		}
		break;
	case DEMO_STATE_WAIT_SET_CUR2:
		if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
        	UART2PrintString( "OK=SET_CUR, VS_COMMIT_CONTROL\r\n" );
        	UART2PrintString( "Byte Count=" );
			UART2PutDec(byteCount);
        	UART2PrintString( "\r\n" );
			packet_dump(temp,byteCount);
        	UART2PrintString( "\r\n" );
			DemoState =DEMO_STATE_SET_ISOCHRONOUS ;
		}
		break;
	case DEMO_STATE_SET_ISOCHRONOUS:
		if(USBHostIssueDeviceRequest( deviceAddress, 0x01, USB_REQUEST_SET_INTERFACE,
            0x06/*Alternate Setting:0x1*/, 0x01/*interface:0x03*/, 0, NULL, USB_DEVICE_REQUEST_SET,
            0x00 )== USB_SUCCESS){
          	UART2PrintString( "USB_REQUEST_SET_INTERFACE=OK!\r\n" );
			DemoState =DEMO_STATE_WAIT_SET_ISOCHRONOUS ;
		}
		break;
	case DEMO_STATE_WAIT_SET_ISOCHRONOUS:
		if(USBHostReadIsochronous(deviceAddress,0x81,&isocData) == USB_SUCCESS){
          		//UART2PrintString( "USBHostReadIsochronous=OK!\r\n" );
			DemoState = DEMO_STATE_ERROR;
		}
		break;
    case DEMO_STATE_ERROR:
        break;
    default:
        DemoState = DEMO_INITIALIZE;
        break;
    }
    //DelayMs(1); // 1ms delay
} // ManageDemoState
コード例 #25
0
/****************************************************************************
  Function:
    USB_HID_RPT_DESC_ERROR _USBHostHID_Parse_Report(BYTE* hidReportDescriptor
                                 ,WORD lengthOfDescriptor, WORD pollRate,
                                  BYTE interfaceNum)

  Description:
    This function is called by usb_host_hid.c after a valid configuration
    device is found. This function parses the report descriptor and stores
    data in data structures. Application can access these data structures
    to understand report format and device capabilities

  Precondition:
    None

  Parameters:
    BYTE* hidReportDescriptor - Pointer to raw report descriptor
    WORD  lengthOfDescriptor  - Length of Report Descriptor
    WORD  pollRate            - Poll rate of the report
    BYTE interfaceNum         - interface number of the respective report
                                descriptor.

  Return Values:
    USB_HID_RPT_DESC_ERROR    - Returns error code(enum) if found while
                                parsing the report descriptor

  Remarks:
    None
***************************************************************************/
USB_HID_RPT_DESC_ERROR _USBHostHID_Parse_Report(BYTE* hidReportDescriptor , WORD lengthOfDescriptor , WORD pollRate, BYTE interfaceNum)
{
    WORD  sizeRequired = 0;
    WORD  len_to_be_parsed =0;
    BYTE* currentRptDescPtr = NULL;
    BYTE* assignMem = NULL;
    /* Main Item Vars */
    HID_COLLECTION *collectionLocal = NULL;
    HID_REPORT *reportLocal = NULL;

    /* Global Item Vars */
    HID_REPORT *lreport = NULL;
    BYTE lreportIndex = (BYTE)NULL;

    /* Local Item Vars */
    HID_DESIGITEM *ldesignatorItem = NULL;
    HID_STRINGITEM *lstringItem = NULL;
    HID_USAGEITEM *lusageItem = NULL;

    /*HID  Error */
    USB_HID_RPT_DESC_ERROR lhidError = HID_ERR;

    HID_ITEM_INFO item;

    BYTE  i=0;
    BYTE  dataByte=0 ;
    BYTE  ldataSize=0;

    if((hidReportDescriptor == NULL) ||(lengthOfDescriptor == 0))
    {
        /* set error flag */
        return(HID_ERR_NullPointer);
    }

    _USBHostHID_InitDeviceRptInfo();

    deviceRptInfo.interfaceNumber = interfaceNum;  // update interface number for the report
    deviceRptInfo.reportPollingRate = pollRate;

    len_to_be_parsed = lengthOfDescriptor;
    currentRptDescPtr = hidReportDescriptor;

    while(len_to_be_parsed > 0)    /* First parse to calculate the space required for all the items */
    {
        item.ItemDetails.val = *currentRptDescPtr;
        /* Data need not be parsed at this point */
        ldataSize = item.ItemDetails.ItemSize ;
        if(item.ItemDetails.ItemSize == 3)
            ldataSize = 4;

        currentRptDescPtr += (ldataSize+1) ; /* point to next item i.e size of item data + 1(item detail) */
        len_to_be_parsed -= (ldataSize+1);   /* remaining bytes = current - (length of data + 1)*/

        switch (item.ItemDetails.ItemType)
        {
        case HIDType_Main:           /* Main Items */
            switch (item.ItemDetails.ItemTag)
            {
            case HIDTag_Collection:
                deviceRptInfo.collections++;
                deviceRptInfo.collectionNesting++;
                if (deviceRptInfo.collectionNesting > deviceRptInfo.maxCollectionNesting)
                    deviceRptInfo.maxCollectionNesting = deviceRptInfo.collectionNesting;
                break;
            case HIDTag_EndCollection:
                if (deviceRptInfo.collectionNesting-- == 0)
                    lhidError = HID_ERR_UnexpectedEndCollection ;/* Error: UnexpectedEndCollection */
                break;
            case HIDTag_Input:
            case HIDTag_Output:
            case HIDTag_Feature:
                deviceRptInfo.reportItems++;
                break;
            default :
                break;
            }
            break;
        case HIDType_Global:         /* Global Items */
            switch (item.ItemDetails.ItemTag)
            {
            case HIDTag_ReportID:
                deviceRptInfo.reports++;
                break;
            case HIDTag_Push:
                deviceRptInfo.globalsNesting++;
                if (deviceRptInfo.globalsNesting > deviceRptInfo.maxGlobalsNesting)
                    deviceRptInfo.maxGlobalsNesting = deviceRptInfo.globalsNesting;
                break;
            case HIDTag_Pop:
                deviceRptInfo.globalsNesting--;
                if (deviceRptInfo.globalsNesting > deviceRptInfo.maxGlobalsNesting)
                    lhidError = HID_ERR_UnexpectedPop ;/* Error: global nesting rolled to negative ... */
                break;
            default :
                break;
            }
            break;
        case HIDType_Local:          /* Local Item */
            switch (item.ItemDetails.ItemTag)
            {
            case HIDTag_Usage:
                deviceRptInfo.usages++;
                break;
            case HIDTag_UsageMinimum:
            case HIDTag_UsageMaximum:
                deviceRptInfo.usageRanges++;
                break;
            case HIDTag_StringIndex:
                deviceRptInfo.strings++;
                break;
            case HIDTag_StringMinimum:
            case HIDTag_StringMaximum:
                deviceRptInfo.stringRanges++;
                break;
            case HIDTag_DesignatorIndex:
                deviceRptInfo.designators++;
                break;
            case HIDTag_DesignatorMinimum:
            case HIDTag_DesignatorMaximum:
                deviceRptInfo.designatorRanges++;
                break;
            default :
                break;
            }
            break;
        default :
            break;

        }
    }

    if(lhidError)
    {
        return(lhidError);
    }

    if (deviceRptInfo.collectionNesting != 0) return(HID_ERR_MissingEndCollection) /* HID_RPT_DESC_FORMAT_IMPROPER */;

    if (deviceRptInfo.collections == 1) return(HID_ERR_MissingTopLevelCollection) /* HID_RPT_DESC_FORMAT_IMPROPER */;

    if (deviceRptInfo.reportItems == 0) return(HID_ERR_NoReports)/* HID_RPT_DESC_FORMAT_IMPROPER */;

    if ((deviceRptInfo.usageRanges & 1) == 1) return(HID_ERR_UnmatchedUsageRange)/* HID_RPT_DESC_FORMAT_IMPROPER */;

    if ((deviceRptInfo.stringRanges & 1) == 1) return(HID_ERR_UnmatchedStringRange)/* HID_RPT_DESC_FORMAT_IMPROPER */;

    if ((deviceRptInfo.designatorRanges & 1) == 1) return(HID_ERR_UnmatchedDesignatorRange)/* HID_RPT_DESC_FORMAT_IMPROPER */;


    /* usages , strings & descriptors are in pair */
    deviceRptInfo.usages += (deviceRptInfo.usageRanges/2);
    deviceRptInfo.strings += (deviceRptInfo.stringRanges/2);
    deviceRptInfo.designators += (deviceRptInfo.designatorRanges/2);

    /* Calculate space required */

    sizeRequired = (sizeof(HID_COLLECTION) * deviceRptInfo.collections)
                   + (sizeof(HID_REPORTITEM) * deviceRptInfo.reportItems)
                   + (sizeof(HID_REPORT) * deviceRptInfo.reports)
                   + (sizeof(HID_USAGEITEM) * deviceRptInfo.usages)
                   + (sizeof(HID_STRINGITEM) * deviceRptInfo.strings)
                   + (sizeof(HID_DESIGITEM) * deviceRptInfo.designators)
                   + (sizeof(int) * deviceRptInfo.maxCollectionNesting)
                   + (sizeof(HID_GLOBALS) * deviceRptInfo.maxGlobalsNesting);

    if (parsedDataMem != NULL)
    {
        freezHID( parsedDataMem );
    }

    parsedDataMem = (BYTE*) malloc(sizeRequired);

#ifdef DEBUG_MODE
    UART2PrintString( "HID: Memory for Report Descriptor: " );
    UART2PutHex( sizeRequired );
#endif

    if (parsedDataMem == NULL) return(HID_ERR_NotEnoughMemory); /* Error: Not enough memory */
    assignMem = (BYTE*) parsedDataMem;

    /* Allocate Space */
    itemListPtrs.collectionList = (HID_COLLECTION *) assignMem;
    assignMem += (sizeof(HID_COLLECTION) * deviceRptInfo.collections);
    itemListPtrs.reportItemList = (HID_REPORTITEM *) assignMem;
    assignMem += (sizeof(HID_REPORTITEM) * deviceRptInfo.reportItems);
    itemListPtrs.reportList = (HID_REPORT *) assignMem;
    assignMem += (sizeof(HID_REPORT) * deviceRptInfo.reports);
    itemListPtrs.usageItemList = (HID_USAGEITEM *) assignMem;
    assignMem += (sizeof(HID_USAGEITEM) * deviceRptInfo.usages);
    itemListPtrs.stringItemList = (HID_STRINGITEM *) assignMem;
    assignMem += (sizeof(HID_STRINGITEM) * deviceRptInfo.strings);
    itemListPtrs.designatorItemList = (HID_DESIGITEM *) assignMem;
    assignMem += (sizeof(HID_DESIGITEM) * deviceRptInfo.designators);
    itemListPtrs.collectionStack = (BYTE *) assignMem;
    assignMem += (sizeof(int) * deviceRptInfo.maxCollectionNesting);
    itemListPtrs.globalsStack = (HID_GLOBALS *) assignMem;

    _USBHostHID_InitDeviceRptInfo();

//  Initialize the virtual collection

    collectionLocal = itemListPtrs.collectionList;
    collectionLocal->data = 0;
    collectionLocal->firstChild = 0;
    collectionLocal->firstReportItem = 0;
    collectionLocal->firstUsageItem = 0;
    collectionLocal->nextSibling = 0;
    collectionLocal->parent = 0;
    collectionLocal->reportItems = 0;
    collectionLocal->usageItems = 0;
    collectionLocal->usagePage = 0;

//  Initialize the default report

    reportLocal = itemListPtrs.reportList;
    reportLocal->featureBits = 0;
    reportLocal->inputBits = 0;
    reportLocal->outputBits = 0;
    reportLocal->reportID = 0;

    /* re-init ptr to Rpt Descp & Length of Descp */
    len_to_be_parsed = lengthOfDescriptor;
    currentRptDescPtr = hidReportDescriptor;

#ifdef DEBUG_MODE
    UART2PrintString( "HID-HOST: ... 2nd Parse \n" );
#endif


    while(len_to_be_parsed > 0)     /* Second parse to fill the tables with each item detail */
    {
        item.ItemDetails.val = *currentRptDescPtr;
        item.Data.uItemData = 0;

        ldataSize = item.ItemDetails.ItemSize ;
        if(item.ItemDetails.ItemSize == 3)
            ldataSize = 4;

        currentRptDescPtr++; /* ptr points to data */
        for (i = 0; i < ldataSize; i++)
        {
            dataByte = *currentRptDescPtr++;  /* signed data will be taken care in ItemTag it is expected */
            item.Data.uItemData |= ((DWORD)dataByte << (i*8));
        }

        len_to_be_parsed -= (ldataSize+1);   /* remaining bytes = current - (length of current item + 1)*/

        switch(item.ItemDetails.ItemType)
        {
        case HIDType_Main:   /* look for Main Items*/
            switch(item.ItemDetails.ItemTag)
            {
            case HIDTag_Input :
            case HIDTag_Output :
            case HIDTag_Feature :
                lhidError = _USBHostHID_Parse_ReportType(&item);
                break;

            case HIDTag_Collection :
                _USBHostHID_Parse_Collection(&item);
                break;

            case HIDTag_EndCollection :
                _USBHostHID_Parse_EndCollection(&item);
                break;
            }
            break;

        case HIDType_Global:   /* look for Global Items*/
            switch(item.ItemDetails.ItemTag)
            {
            case HIDTag_UsagePage :
                deviceRptInfo.globals.usagePage = item.Data.uItemData;
                break;

            case HIDTag_LogicalMinimum : /* convert to signed val */
                //  Sign extend one value
                _USBHostHID_ConvertDataToSigned(&item);
                deviceRptInfo.globals.logicalMinimum = item.Data.sItemData;
                break;

            case HIDTag_LogicalMaximum :/* convert to signed val */
                //  Sign extend one value
                _USBHostHID_ConvertDataToSigned(&item);
                deviceRptInfo.globals.logicalMaximum = item.Data.uItemData;
                break;

            case HIDTag_PhysicalMinimum :/* convert to signed val */
                //  Sign extend one value
                _USBHostHID_ConvertDataToSigned(&item);
                deviceRptInfo.globals.physicalMinimum = item.Data.uItemData;
                break;

            case HIDTag_PhysicalMaximum :/* convert to signed val */
                //  Sign extend one value
                _USBHostHID_ConvertDataToSigned(&item);
                deviceRptInfo.globals.physicalMaximum = item.Data.uItemData;
                break;

            case HIDTag_UnitExponent :
                deviceRptInfo.globals.unitExponent = item.Data.uItemData;
                break;

            case HIDTag_ReportSize :
                deviceRptInfo.globals.reportsize = item.Data.uItemData;
                if (deviceRptInfo.globals.reportsize == 0)
                    lhidError = HID_ERR_ZeroReportSize;
                break;

            case HIDTag_ReportID :
                if (item.Data.uItemData)
                {
//                               Look for the Report ID in the table

                    lreportIndex = 0;
                    while ((lreportIndex < deviceRptInfo.reports)
                            && (itemListPtrs.reportList[lreportIndex].reportID != item.Data.uItemData))
                        lreportIndex++;

//                               initialize the entry if it's new and there's room for it
//                               Start with 8 bits for the Report ID

                    if (lreportIndex == deviceRptInfo.reports)
                    {
                        lreport = &itemListPtrs.reportList[deviceRptInfo.reports++];
                        lreport->reportID = item.Data.uItemData;
                        lreport->inputBits = 8;
                        lreport->outputBits = 8;
                        lreport->featureBits = 8;
                    }

//                               remember which report is being processed

                    deviceRptInfo.globals.reportID = item.Data.uItemData;
                    deviceRptInfo.globals.reportIndex = lreportIndex;
                }
                else
                {
                    lhidError = HID_ERR_ZeroReportID;
                }
                break;

            case HIDTag_ReportCount :
                if (item.Data.uItemData)
                {
                    deviceRptInfo.globals.reportCount = item.Data.uItemData;
                }
                else
                {
                    lhidError = HID_ERR_ZeroReportCount;
                }
                break;

            case HIDTag_Push :
                itemListPtrs.globalsStack[deviceRptInfo.globalsNesting++] =  deviceRptInfo.globals;
                break;

            case HIDTag_Pop :
                deviceRptInfo.globals = itemListPtrs.globalsStack[--deviceRptInfo.globalsNesting] ;
                break;

            }
            break;

        case HIDType_Local:  /* look for Local Items*/
            switch(item.ItemDetails.ItemTag)
            {
            case HIDTag_Usage :
                lusageItem = &itemListPtrs.usageItemList[deviceRptInfo.usageItems++];
                lusageItem->isRange = FALSE;
                if (item.ItemDetails.ItemSize == 3) /* 4 data bytes */
                {
                    lusageItem->usagePage = item.Data.uItemData >> 16;
                    lusageItem->usage = item.Data.uItemData & 0x00FF;
                }
                else
                {
                    lusageItem->usagePage = deviceRptInfo.globals.usagePage;
                    lusageItem->usage = item.Data.uItemData;
                }
                break;

            case HIDTag_UsageMinimum :
                if(deviceRptInfo.haveUsageMax)
                {
                    lusageItem = &itemListPtrs.usageItemList[deviceRptInfo.usageItems++];
                    lusageItem->isRange = TRUE;
                    if(item.ItemDetails.ItemSize == 3)
                    {
                        lusageItem->usagePage = item.Data.uItemData >> 16;
                        lusageItem->usageMinimum = item.Data.uItemData & 0x00FFL;
                    }
                    else
                    {
コード例 #26
0
ファイル: main.c プロジェクト: Athuli7/Microchip
/*************************************************************************
 * Function:        ManageDemoState
 *
 * Preconditions:   The DemoState global variable must be initialized to
 *                  DEMO_STATE_IDLE (0).  (This occurs on reset.)
 *
 * Input:           DemoState (global)
 *                  Actions selected based value of DemoState on function
 *                  entry.
 *
 *                  deviceAddress (global)
 *                  May use device address to access device, depending on
 *                  state.
 *
 *                  DataPacket (global)
 *                  May read data from packet buffer, depending on state.
 *
 * Output:          DemoState (global)
 *                  Updates demo state as appropriate.
 *
 *                  DataPacket (global)
 *                  May cause data in the packet buffer to be updated,
 *                  depending on state.
 *
 * Returns:         None
 *
 * Side Effects:    Depend on state transition
 *
 * Overview:        This routine maintains the state of the application,
 *                  updateing global data and taking actions as necessary
 *                  to maintain the custom demo operations.
 *************************************************************************/
void ManageDemoState ( void )
{
    BYTE RetVal;

    BlinkStatus();

    // Watch for device timeouts
//    if (MSTimerGetTime() > DEMO_TIMEOUT_LIMIT)
//    {
//        if (DemoState == DEMO_STATE_IDLE)
//        {
//            LCDWriteLine( 2, "Awaiting Device" );
//        }
//        else
//        {
//            UART2PrintString( "Device Time-out Error!\r\n" );
//            LCDWriteLine( 2, "Dev Time-out Err" );
//            DemoState = DEMO_STATE_ERROR;
//        }
//    }

    // Watch for device detaching
    if (USBHostGenericDeviceDetached(deviceAddress) && deviceAddress != 0)
    {
        UART2PrintString( "Generic demo device detached - polled\r\n" );
        DemoState = DEMO_INITIALIZE;
        deviceAddress   = 0;
    }

    switch (DemoState)
    {
    case DEMO_INITIALIZE:
        InitLcdMessage();
        DemoState = DEMO_STATE_IDLE;
        break;

    /** Idle State:  Loops here until attach **/
    case DEMO_STATE_IDLE:
        if (CheckForNewAttach())
        {
            DemoState = DEMO_STATE_GET_DEV_VERSION;
        }
        break;

    /** Sequence: Read Dev FW Version **/
    case DEMO_STATE_GET_DEV_VERSION:
        // Send the Read Version command
        DataPacket.CMD = READ_VERSION;
        DataPacket.len = 2;
        if (!USBHostGenericTxIsBusy(deviceAddress))
        {
            if ( (RetVal=USBHostGenericWrite(deviceAddress, &DataPacket, 2)) == USB_SUCCESS )
            {
                DemoState = DEMO_STATE_WAITING_VER_REQ;
            }
            else
            {
                UART2PrintString( "1 Device Write Error 0x" );
                UART2PutHex(RetVal);
                UART2PrintString( "\r\n" );
                LCDWriteLine( 2, "Dev Write Error " );
            }
        }
        break;

    case DEMO_STATE_WAITING_VER_REQ:
        if (!USBHostGenericTxIsBusy(deviceAddress) )
            DemoState = DEMO_STATE_READ_DEV_VERSION;
        break;

    case DEMO_STATE_READ_DEV_VERSION:
        if (!USBHostGenericRxIsBusy(deviceAddress))
        {
            if ( (RetVal=USBHostGenericRead(deviceAddress, &DataPacket, 4)) == USB_SUCCESS )
            {
                DemoState = DEMO_STATE_WAITING_READ_VER;
            }
            else
            {
                UART2PrintString( "1 Device Read Error 0x" );
                UART2PutHex(RetVal);
                UART2PrintString( "\r\n" );
                LCDWriteLine( 2, "Dev Read Error  " );
            }
        }
        break;

    case DEMO_STATE_WAITING_READ_VER:
        if (!USBHostGenericRxIsBusy(deviceAddress))
            DemoState = DEMO_STATE_VERIFY_DEV_FW_VER;
        break;

    case DEMO_STATE_VERIFY_DEV_FW_VER:
        if (ValidateAndDisplayDeviceFwVersion())
            DemoState = DEMO_STATE_GET_TEMPERATURE;
        else
            DemoState = DEMO_STATE_ERROR;
        break;

    /** Sequence: Read Temperature Sensor Data **/
    case DEMO_STATE_GET_TEMPERATURE:
        // Send the Read Temperature command
        DataPacket.CMD = RD_TEMP;
        DataPacket.len = 2;
        if (!USBHostGenericTxIsBusy(deviceAddress))
        {
            if ( (RetVal=USBHostGenericWrite(deviceAddress, &DataPacket, 2)) == USB_SUCCESS)
            {
                DemoState = DEMO_STATE_WAITING_GET_TEMP;
            }
            else
            {
                UART2PrintString( "2 Device Write Error 0x" );
                UART2PutHex(RetVal);
                UART2PrintString( "\r\n" );
                LCDWriteLine( 2, "Dev Write Error " );
            }
        }
        break;

    case DEMO_STATE_WAITING_GET_TEMP:
        if (!USBHostGenericTxIsBusy(deviceAddress) )
        {
            DemoState = DEMO_STATE_READ_TEMPERATURE;
        }
        break;

    case DEMO_STATE_READ_TEMPERATURE:
        if (!USBHostGenericRxIsBusy(deviceAddress))
        {
            if ( (RetVal=USBHostGenericRead(deviceAddress, &DataPacket, 3)) == USB_SUCCESS)
            {
                DemoState = DEMO_STATE_WAITING_READ_TEMP;
            }
            else
            {
                UART2PrintString( "2 Device Read Error 0x" );
                UART2PutHex(RetVal);
                UART2PrintString( "\r\n" );
                LCDWriteLine( 2, "Dev Read Error  " );
            }
        }
        break;

    case DEMO_STATE_WAITING_READ_TEMP:
        if (!USBHostGenericRxIsBusy(deviceAddress))
        {
            DemoState = DEMO_STATE_DISPLAY_TEMPERATURE;
        }
        break;

    case DEMO_STATE_DISPLAY_TEMPERATURE:
        DisplayTemperature();
        DemoState = DEMO_STATE_GET_POT;
        break;

    /** Sequence: Read POT Sensor Data **/
    case DEMO_STATE_GET_POT:
        // Send the Read POT command
        DataPacket.CMD = RD_POT;
        DataPacket.len = 2;
        if (!USBHostGenericTxIsBusy(deviceAddress))
        {
            if ( (RetVal=USBHostGenericWrite(deviceAddress, &DataPacket, 2)) == USB_SUCCESS)
            {
                DemoState = DEMO_STATE_WAITING_GET_POT;
            }
            else
            {
                UART2PrintString( "3 Device Write Error 0x" );
                UART2PutHex(RetVal);
                UART2PrintString( "\r\n" );
                LCDWriteLine( 2, "Dev Write Error " );
            }
        }
        break;

    case DEMO_STATE_WAITING_GET_POT:
        if (!USBHostGenericTxIsBusy(deviceAddress) )
            DemoState = DEMO_STATE_READ_POT;
        break;

    case DEMO_STATE_READ_POT:
        if (!USBHostGenericRxIsBusy(deviceAddress))
        {
            if ( (RetVal=USBHostGenericRead(deviceAddress, &DataPacket, 3)) == USB_SUCCESS)
            {
                DemoState = DEMO_STATE_WAITING_READ_POT;
            }
            else
            {
                UART2PrintString( "3 Device Read Error 0x" );
                UART2PutHex(RetVal);
                UART2PrintString( "\r\n" );
                LCDWriteLine( 2, "Dev Read Error  " );
            }
        }
        break;

    case DEMO_STATE_WAITING_READ_POT:
        if (!USBHostGenericRxIsBusy(deviceAddress))
            DemoState = DEMO_STATE_DISPLAY_POT;
        break;

    case DEMO_STATE_DISPLAY_POT:
        DisplayPot();
        DemoState = DEMO_STATE_SEND_SET_LED;
        break;

    /** Sequence:  Update LEDs **/
    case DEMO_STATE_SEND_SET_LED:
        // Send the set-LED command
        DataPacket.CMD = UPDATE_LED;
        DataPacket.len = 3;
        if (Switch3WasPressed())
        {
            DataPacket.led_num    = 3;  // LED 3 on original PIC18 FS USB board
            DataPacket.led_status = LEDState.bits.b3 ^ 1;
        }
        else if (Switch6WasPressed())
        {
            DataPacket.led_num    = 4;  // LED 4 on original PIC18 FS USB board
            DataPacket.led_status = LEDState.bits.b4 ^ 1;
        }
        else
        {
            DemoState = DEMO_STATE_GET_TEMPERATURE;
            break;
        }
        if (!USBHostGenericTxIsBusy(deviceAddress))
        {
            if ( (RetVal=USBHostGenericWrite(deviceAddress, &DataPacket, 3)) == USB_SUCCESS)
            {
                DemoState = DEMO_STATE_WAITING_SET_LED;
            }
            else
            {
                UART2PrintString( "4 Device Write Error 0x" );
                UART2PutHex(RetVal);
                UART2PrintString( "\r\n" );
                LCDWriteLine( 2, "Dev Write Error " );
            }
        }
        break;

    case DEMO_STATE_WAITING_SET_LED:
        if (!USBHostGenericTxIsBusy(deviceAddress) )
            DemoState = DEMO_STATE_READ_SET_LED_RESP;
        break;

    case DEMO_STATE_READ_SET_LED_RESP:
        if (!USBHostGenericRxIsBusy(deviceAddress))
        {
            DataPacket.CMD = CMD_INVALID;
            if ( (RetVal=USBHostGenericRead(deviceAddress, &DataPacket, 1)) == USB_SUCCESS)
            {
                DemoState = DEMO_STATE_WAITING_LED_RESP;
            }
            else
            {
                UART2PrintString( "4 Device Read Error 0x" );
                UART2PutHex(RetVal);
                UART2PrintString( "\r\n" );
                LCDWriteLine( 2, "Dev Read Error  " );
            }
        }
        break;

    case DEMO_STATE_WAITING_LED_RESP:
        if (!USBHostGenericRxIsBusy(deviceAddress))
            DemoState = DEMO_STATE_UPDATE_LED_STATE;
        break;

    case DEMO_STATE_UPDATE_LED_STATE:
        if (DataPacket.CMD == UPDATE_LED)   // CMD updated by read from device
        {
            if (DataPacket.led_num == 3)    // led_num left-over from set-LED command send
            {
                LEDState.bits.b3 ^= 1;
//                mLED_10_Toggle();
            }
            else if (DataPacket.led_num == 4)
            {
                LEDState.bits.b4 ^= 1;
//                mLED_9_Toggle();
            }
        }
        DemoState = DEMO_STATE_GET_TEMPERATURE;
        break;

    /** Error state:  Hold here until detached **/
    case DEMO_STATE_ERROR:                          // To Do: Flash LEDs
        break;

    default:
        DemoState = DEMO_INITIALIZE;
        break;
    }

    DelayMs(1); // 1ms delay

} // ManageDemoState
コード例 #27
0
ファイル: main.c プロジェクト: Athuli7/Microchip
BOOL USB_ApplicationEventHandler ( BYTE address, USB_EVENT event, void *data, DWORD size )
{
    #ifdef USB_GENERIC_SUPPORT_SERIAL_NUMBERS
        BYTE i;
    #endif

    // Handle specific events.
    switch ( (INT)event )
    {
        case EVENT_GENERIC_ATTACH:
            if (size == sizeof(GENERIC_DEVICE_ID))
            {
                deviceAddress   = ((GENERIC_DEVICE_ID *)data)->deviceAddress;
                DemoState = DEMO_STATE_GET_DEV_VERSION;
                UART2PrintString( "Generic demo device attached - event, deviceAddress=" );
                UART2PutDec( deviceAddress );
                UART2PrintString( "\r\n" );
                #ifdef USB_GENERIC_SUPPORT_SERIAL_NUMBERS
                    for (i=1; i<((GENERIC_DEVICE_ID *)data)->serialNumberLength; i++)
                    {
                        UART2PutChar( ((GENERIC_DEVICE_ID *)data)->serialNumber[i] );
                    }
                #endif
                UART2PrintString( "\r\n" );
                return TRUE;
            }
            break;

        case EVENT_GENERIC_DETACH:
            deviceAddress   = 0;
            DemoState = DEMO_INITIALIZE;
            UART2PrintString( "Generic demo device detached - event\r\n" );
            return TRUE;

        case EVENT_GENERIC_TX_DONE:           // The main state machine will poll the driver.
        case EVENT_GENERIC_RX_DONE:
            return TRUE;

        case EVENT_VBUS_REQUEST_POWER:
            // We'll let anything attach.
            return TRUE;

        case EVENT_VBUS_RELEASE_POWER:
            // We aren't keeping track of power.
            return TRUE;

        case EVENT_HUB_ATTACH:
            UART2PrintString( "\r\n***** USB Error - hubs are not supported *****\r\n" );
            return TRUE;
            break;

        case EVENT_UNSUPPORTED_DEVICE:
            UART2PrintString( "\r\n***** USB Error - device is not supported *****\r\n" );
            return TRUE;
            break;

        case EVENT_CANNOT_ENUMERATE:
            UART2PrintString( "\r\n***** USB Error - cannot enumerate device *****\r\n" );
            return TRUE;
            break;

        case EVENT_CLIENT_INIT_ERROR:
            UART2PrintString( "\r\n***** USB Error - client driver initialization error *****\r\n" );
            return TRUE;
            break;

        case EVENT_OUT_OF_MEMORY:
            UART2PrintString( "\r\n***** USB Error - out of heap memory *****\r\n" );
            return TRUE;
            break;

        case EVENT_UNSPECIFIED_ERROR:   // This should never be generated.
            UART2PrintString( "\r\n***** USB Error - unspecified *****\r\n" );
            return TRUE;
            break;

        case EVENT_SUSPEND:
        case EVENT_DETACH:
        case EVENT_RESUME:
        case EVENT_BUS_ERROR:
            return TRUE;
            break;

        default:
            break;
    }

    return FALSE;

} // USB_ApplicationEventHandler
コード例 #28
0
BOOL USBHostUSBBTInit( BYTE address, DWORD flags, BYTE clientDriverID )
{
    int i = 0;
    BYTE   *descriptor;

    UART2PrintString( "USBBT init\r\n" );

    descriptor = USBHostGetCurrentConfigurationDescriptor( address );

    // Find the next interface descriptor.
    while (i < ((USB_CONFIGURATION_DESCRIPTOR *)descriptor)->wTotalLength)
    {
        // See if we are pointing to an interface descriptor.
        if (descriptor[i+1] == USB_DESCRIPTOR_INTERFACE)
        {
            g_usbbt.endpointCtrl = 0;
            g_usbbt.endpointInt = 0;
            g_usbbt.endpointBulkIN = 0;
            g_usbbt.endpointBulkOUT = 0;

            // Scan for endpoint descriptors.
            i += descriptor[i];
            while (descriptor[i+1] == USB_DESCRIPTOR_ENDPOINT)
            {
                if (descriptor[i+3] == 0x02) // Bulk
                {
                    if (((descriptor[i+2] & 0x80) == 0x80) && (g_usbbt.endpointBulkIN == 0))
                    {
                        g_usbbt.endpointBulkIN = descriptor[i+2];
                    }
                    if (((descriptor[i+2] & 0x80) == 0x00) && (g_usbbt.endpointBulkOUT == 0))
                    {
                        g_usbbt.endpointBulkOUT = descriptor[i+2];
                    }
                } else if(descriptor[i+3] == 0x03) // Interrupt
                {
                    g_usbbt.endpointInt = descriptor[i+2];
                } else if(descriptor[i+3] == 0x00) // Control
                {
                    g_usbbt.endpointCtrl = descriptor[i+2];
                }
                i += descriptor[i];
            }

            if ((g_usbbt.endpointInt != 0) && (g_usbbt.endpointBulkIN != 0) && (g_usbbt.endpointBulkOUT != 0))
            {
                g_usbbt.initialized = 1;
                g_usbbt.deviceAddress = address;
                g_usbbt.clientDriverID = clientDriverID;
                /*				if(g_usbbt.endpointBulkIN_Busy == 0)
                				{
                					USBHostBlukRead(address,bulk_buf,MAX_DATA_PACKET_LENGTH);
                				}
                				if(g_usbbt.endpointInt_Busy == 0)
                				{
                					USBHostIntRead(address,int_buf,MAX_DATA_PACKET_LENGTH);
                				}*/
                UART2PrintString( " Control endpoint : " );
                UART2PutHex( g_usbbt.endpointCtrl );
                UART2PrintString( " Interrupt endpoint IN: " );
                UART2PutHex( g_usbbt.endpointInt );
                UART2PrintString( " Bulk endpoint IN: " );
                UART2PutHex( g_usbbt.endpointBulkIN );
                UART2PrintString( " Bulk endpoint OUT: " );
                UART2PutHex( g_usbbt.endpointBulkOUT );
                UART2PrintString( "\r\n" );
                usb_bt_init();
                return TRUE;
            }
        }
        // Jump to the next descriptor in this configuration.
        i += descriptor[i];
    }
    return FALSE;
}
コード例 #29
0
BOOL USBHostUSBBTEventHandler( BYTE address, USB_EVENT event, void *data, DWORD size )
{
    switch (event)
    {
    case EVENT_NONE:			 // No event occured (NULL event)
        return TRUE;
        break;

    case EVENT_DETACH:			 // USB cable has been detached (data: BYTE, address of device)
        g_usbbt.initialized = 0;
        g_usbbt.deviceAddress = 0;
        UART2PrintString( "USBBT detach \r\n" );
        return TRUE;
        break;

    case EVENT_TRANSFER:		 // A USB transfer has completed - optional
#if defined( USB_ENABLE_TRANSFER_EVENT )
        if ( (data != NULL) && (size == sizeof(HOST_TRANSFER_DATA)) )
        {
            DWORD i;
            DWORD dataCount = ((HOST_TRANSFER_DATA *)data)->dataCount;
            BYTE *userData = ((HOST_TRANSFER_DATA *)data)->pUserData;
//			    BYTE errorCode = ((HOST_TRANSFER_DATA *)data)->bErrorCode;

            if ( ((HOST_TRANSFER_DATA *)data)->bEndpointAddress == g_usbbt.endpointBulkIN )
            {
                g_usbbt.endpointBulkIN_Busy = 0;
                if(dataCount != 0)
                {
                    UART2PrintString( "BulkIN  " );
                    for(i = 0; i < dataCount; i++)
                    {
                        UART2PutHex(userData[i]);
                    }
                    UART2PrintString( "\r\n" );
                    // bt event
                    usb_bt_call_handler(USB_BT_EVENT_BULK_READ,userData,dataCount);
                }
            }
            else if ( ((HOST_TRANSFER_DATA *)data)->bEndpointAddress == g_usbbt.endpointBulkOUT )
            {
                UART2PrintString( "BulkOUT \r\n" );
                g_usbbt.endpointBulkOUT_Busy = 0;
                uint8_t dummy_event = DAEMON_EVENT_HCI_PACKET_SENT;
                packet_handler(HCI_EVENT_PACKET, &dummy_event, 1);
            }
            else if ( ((HOST_TRANSFER_DATA *)data)->bEndpointAddress == g_usbbt.endpointCtrl )
            {
                UART2PrintString( "Ctrl    \r\n" );
                g_usbbt.endpointCtrl_Busy = 0;
                uint8_t dummy_event = DAEMON_EVENT_HCI_PACKET_SENT;
                packet_handler(HCI_EVENT_PACKET, &dummy_event, 1);
            }
            else if ( ((HOST_TRANSFER_DATA *)data)->bEndpointAddress == g_usbbt.endpointInt )
            {
                g_usbbt.endpointInt_Busy = 0;
                if(dataCount != 0)
                {
                    UART2PrintString( "Int     " );
                    for(i = 0; i < dataCount; i++)
                    {
                        UART2PutHex(userData[i]);
                    }
                    UART2PrintString( "\r\n" );
                    // bt event
                    usb_bt_call_handler(USB_BT_EVENT_INTERRUPT_READ,userData,dataCount);
                }
            }
            else
            {
                return FALSE;
            }

            if(!g_usbbt.endpointCtrl_Busy && !g_usbbt.endpointBulkOUT_Busy)
            {
                if(g_usbbt.endpointBulkIN_Busy == 0)
                {
                    USBHostBlukRead(g_usbbt.deviceAddress,bulk_buf,MAX_DATA_PACKET_LENGTH);
                }
                if(g_usbbt.endpointInt_Busy == 0)
                {
                    USBHostIntRead(g_usbbt.deviceAddress,int_buf,MAX_DATA_PACKET_LENGTH);
                }
            }
            return TRUE;
        }
        else
            return FALSE;
#endif

    case EVENT_SOF:				 // Start of frame - NOT NEEDED
    case EVENT_RESUME:			 // Device-mode resume received
    case EVENT_SUSPEND:			 // Device-mode suspend/idle event received
    case EVENT_RESET:			 // Device-mode bus reset received
    case EVENT_STALL:			 // A stall has occured
    case EVENT_BUS_ERROR:
    default:
        break;
    }

    return FALSE;
}
コード例 #30
0
ファイル: app_host_bridge.c プロジェクト: timwuu/PK3SP24
/*********************************************************************
 * Function: void APP_HostHIDKeyboardTasks(void);
 *
 * Overview: Keeps the demo running.
 *
 * PreCondition: The demo should have been initialized via
 *   the APP_HostHIDKeyboardInitialize()
 *
 * Input: None
 *
 * Output: None
 *
 ********************************************************************/
void APP_HostHIDKeyboardTasks() {
    uint8_t error;
    uint8_t count;

    if (!USBHostHID_ApiDeviceDetect()) {
        if (pickit.state != WAITING_FOR_DEVICE) {
            pickit.state = DEVICE_NOT_CONNECTED;
            
#ifdef DEBUG_MODE
            UART2PrintString("APP: PICkit Disconnected!\n");
#endif
            pickit.inUse = false;

            if (pickit.buffer != NULL) {
                free(pickit.buffer);
                pickit.buffer = NULL;
            }
        }
    }

    switch (pickit.state) {
        case DEVICE_NOT_CONNECTED:
            //PRINT_ClearScreen();
#ifdef DEBUG_MODE
            UART2PrintString("APP: Attach PICkit\n");
#endif            
            pickit.state = WAITING_FOR_DEVICE;
            IEC0bits.U1RXIE=0;
            LED_Off(LED_USB_HOST_HID_KEYBOARD_DEVICE_READY);
            break;

        case WAITING_FOR_DEVICE:
            if (USBHostHID_ApiDeviceDetect()) /* True if report descriptor is parsed with no error */ {
                //PRINT_ClearScreen();
                SYSTEM_Initialize(SYSTEM_STATE_USB_HOST_HID_KEYBOARD);
                LED_On(LED_USB_HOST_HID_KEYBOARD_DEVICE_READY);

                pickit.state = DEVICE_CONNECTED;
                    
                //timwuu 2015.12.31 change control right from timer3 to uart
                TIMER_RequestTick(&APP_HostHIDTimerHandler, 2);  //2ms

            }
            break;

        case DEVICE_CONNECTED:
            break;

        case GET_INPUT_REPORT:
                       
            if (USBHostHID_ApiGetReport(pickit.details.reportID,
                    pickit.details.interfaceNum,
                    pickit.size,
                    pickit.buffer
                    )
                    ) {
                /* Host may be busy/error -- keep trying */
#ifdef DEBUG_MODE
                    UART2PrintString("GET_INPUT_REPORT:BUSY\n");
#endif
            } else {
#ifdef DEBUG_MODE
                    UART2PrintString("GET_INPUT_REPORT:OK\n");
#endif                
                pickit.state = INPUT_REPORT_PENDING;
            }
            break;

        case INPUT_REPORT_PENDING:
            if (USBHostHID_ApiTransferIsComplete(&error, &count)) {
                if (error || (count == 0)) {
#ifdef DEBUG_MODE
                    if(error) UART2PrintString("INPUT_REPORT_PENDING:ERROR\n");
                    if(count==0) UART2PrintString("INPUT_REPORT_PENDING:ZERO\n");
#endif                                 
                    pickit.state = DEVICE_CONNECTED;
                } else {
#ifdef DEBUG_MODE
                    UART2PrintString("INPUT_REPORT_PENDING:OK\n");
#endif
                  
                    UART2PutHex(pickit.buffer[61]);
                    UART2PutHex(pickit.buffer[60]);
                    UART2PutChar(':');
                    
                    pickit.state = DEVICE_CONNECTED;
                    App_ProcessInputReport();
                }
            }
            break;

        case SEND_OUTPUT_REPORT: 
            
            //App_PrepareOutputReport();

            if (USBHostHID_ApiSendReport(pickit.details.reportID,
                    pickit.details.interfaceNum,
                    pickit.size,
                    (uint8_t *)cmdBuffer)) {
                    //pickit.buffer)) {
                /* Host may be busy/error -- keep trying */
#ifdef DEBUG_MODE
                    UART2PrintString("SEND_OUTPUT_REPORT:BUSY\n");
#endif

            } else {
#ifdef DEBUG_MODE
                    UART2PrintString("SEND_OUTPUT_REPORT:OK\n");
#endif
                UB_SetCmdBufferStateEmpty();
                pickit.state = OUTPUT_REPORT_PENDING;
            }
            break;

        case OUTPUT_REPORT_PENDING:
            //timijk 2016.01.13 Issue
            if (USBHostHID_ApiTransferIsComplete(&error, &count)) {
#ifdef DEBUG_MODE
                    UART2PrintString("OUTPUT_REPORT_PENDING\n");
#endif
                //?timwuu 2016.01.02  signal the device is ready for the next command
//                if(error) {
//                    UART2PutChar('*');
//                    UART2PutHex(error);
//                    LATBbits.LATB15 =1;
//                    pickit.state = SEND_OUTPUT_REPORT;  //resent the data
//                }
//                else
//                {
                    U1TXREG = 0x00; //LENGTH ZERO DATA
                    pickit.state = DEVICE_CONNECTED;
//                }
            }
                
            break;

        case ERROR_REPORTED:
            break;

        default:
            break;

    }
}