Пример #1
0
bool AndroidAccessory::isConnected(void)
{
    USB_DEVICE_DESCRIPTOR *devDesc = (USB_DEVICE_DESCRIPTOR *) descBuff;
    byte err;

    refresh();

    if (!connected &&
        usb.getUsbTaskState() >= USB_STATE_CONFIGURING &&
        usb.getUsbTaskState() != USB_STATE_RUNNING) {
        Serial.print(F("\nDevice addressed... "));
        Serial.print(F("Requesting device descriptor.\n"));

        err = usb.getDevDescr(1, 0, 0x12, (char *) devDesc);
        if (err) {
            Serial.print(F("\nDevice descriptor cannot be retrieved. Trying again\n"));
            return false;
        }

        if (isAccessoryDevice(devDesc)) {
            Serial.print(F("found android acessory device\n"));

            connected = configureAndroid();
        } else {
            Serial.print(F("found possible device. swithcing to serial mode\n"));
            switchDevice(1);
        }
    } else if (usb.getUsbTaskState() == USB_DETACHED_SUBSTATE_WAIT_FOR_DEVICE) {
        if (connected)
            Serial.println(F("disconnect\n"));
        connected = false;
    }

    return connected;
}
Пример #2
0
bool AndroidAccessory::connect() {

	USB_DEVICE_DESCRIPTOR *devDesc = (USB_DEVICE_DESCRIPTOR *) descBuff;
    byte err = usb.getDevDescr(1, 0, 0x12, (char *) devDesc);
    if (err) {
    	return false;
    }
    if (isAccessoryDevice(devDesc)) {
    	return configureAndroid();
    } else {
    	switchDevice(1);
    }
    return false;
}
Пример #3
0
//*****************************************************************************
//
//! This function is used to open an instance of the ANDROID driver and configure it as Open Accessory.
//!
//! \param pDevice is a pointer to the device information structure.
//!
//! This function will attempt to open an instance of the ANDROID driver based on
//! the information contained in the pDevice structure.  This call can fail if
//! there are not sufficient resources to open the device.  The function will
//! return a value that should be passed back into USBANDROIDClose() when the
//! driver is no longer needed.
//!
//! \return The function will return a pointer to a ANDROID driver instance.
//
//*****************************************************************************
static void * USBHANDROIDOpen(tUSBHostDevice *pDevice)
{
    int iIdx;
    tEndpointDescriptor *pEndpointDescriptor;
    tInterfaceDescriptor *pInterface;

    UARTprintf("\nStart USBHANDROIDOpen Time=%d\n", g_ulSysTickCount);

    /* For Debug purpose you can also list full Configuration Descriptor & Device Descriptor */
    getConfigDesc(pDevice);
    getDeviceDesc(pDevice);
/*
    UARTprintf("Start pDevice->pConfigDescriptor details Time=%d:\n", g_ulSysTickCount);
    UARTprintf(" bLength=0x%02X (shall be 0x09)\n", pDevice->pConfigDescriptor->bLength);
    UARTprintf(" wTotalLength=0x%04X\n", pDevice->pConfigDescriptor->wTotalLength);
    UARTprintf(" bDescriptorType=0x%02X\n", pDevice->pConfigDescriptor->bDescriptorType);
    UARTprintf(" bNumInterfaces=0x%02X\n", pDevice->pConfigDescriptor->bNumInterfaces);    
    UARTprintf(" bConfigurationValue=0x%02X\n", pDevice->pConfigDescriptor->bConfigurationValue);
    UARTprintf(" iConfiguration=0x%02X\n", pDevice->pConfigDescriptor->iConfiguration);
    UARTprintf(" bmAttributes=0x%02X\n", pDevice->pConfigDescriptor->bmAttributes);
    UARTprintf(" bMaxPower=0x%02X (unit of 2mA)\n\n", pDevice->pConfigDescriptor->bMaxPower);

    UARTprintf("pDevice->DeviceDescriptor details:\n");
    UARTprintf(" bLength=0x%02X (shall be 0x12)\n",  pDevice->DeviceDescriptor.bLength);
    UARTprintf(" bDescriptorType=0x%02X\n",  pDevice->DeviceDescriptor.bDescriptorType);
    UARTprintf(" bcdUSB=0x%02X (USB2.0=0x200)\n",  pDevice->DeviceDescriptor.bcdUSB);
    UARTprintf(" bDeviceClass=0x%02X\n",  pDevice->DeviceDescriptor.bDeviceClass);
    UARTprintf(" bDeviceSubClass=0x%02X\n",  pDevice->DeviceDescriptor.bDeviceSubClass);    
    UARTprintf(" bDeviceProtocol=0x%02X\n",  pDevice->DeviceDescriptor.bDeviceProtocol);
    UARTprintf(" bMaxPacketSize0=0x%02X\n",  pDevice->DeviceDescriptor.bMaxPacketSize0);
    UARTprintf(" idVendor=0x%02X\n",  pDevice->DeviceDescriptor.idVendor);
    UARTprintf(" idProduct=0x%02X\n",  pDevice->DeviceDescriptor.idProduct);
    UARTprintf(" bcdDevice=0x%02X\n",  pDevice->DeviceDescriptor.bcdDevice);
    UARTprintf(" iManufacturer=0x%02X\n",  pDevice->DeviceDescriptor.iManufacturer);        
    UARTprintf(" iProduct=0x%02X\n",  pDevice->DeviceDescriptor.iProduct);    
    UARTprintf(" iSerialNumber=0x%02X\n",  pDevice->DeviceDescriptor.iSerialNumber);    
    UARTprintf(" bNumConfigurations=0x%02X\n",  pDevice->DeviceDescriptor.bNumConfigurations);
    UARTprintf("End pDevice->pConfigDescriptor details Time=%d:\n\n", g_ulSysTickCount);
*/
    // Don't allow the device to be opened without closing first.
    if(g_USBHANDROIDDevice.pDevice)
    {
        UARTprintf("\nUSBHANDROIDOpen return 0 device already opened\n");
        return(0);
    }

    // Save the device pointer.
    g_USBHANDROIDDevice.pDevice = pDevice;

    // Save the callback.
    // The CallBack is the driver callback for any Android ADK events.
    //
    // This function is called to open an instance of an android device.  It
    // should be called before any devices are connected to allow for proper
    // notification of android connection and disconnection. The
    // application should also provide the \e pfnCallback to be notified of Andoid
    // ADK related events like device enumeration and device removal.
    g_USBHANDROIDDevice.pfnCallback = USBHANDROIDCallback;
    
    /* Check Android Accessory device */
    if (isAccessoryDevice(&pDevice->DeviceDescriptor)) 
    {
        UARTprintf("Found Android Accessory device Time=%d\n", g_ulSysTickCount);

        // Get the interface descriptor.
        pInterface = USBDescGetInterface(pDevice->pConfigDescriptor, 0, 0);    

        // Loop through the endpoints of the device.
        for(iIdx = 0; iIdx < 3; iIdx++)
        {
            // Get the first endpoint descriptor.
             pEndpointDescriptor =
            USBDescGetInterfaceEndpoint(pInterface, iIdx,
            pDevice->ulConfigDescriptorSize);
            
            UARTprintf("\nEndpoint%d USBDescGetInterfaceEndpoint()=pEndpointDescriptor res=0x%08X\n", iIdx, pEndpointDescriptor);

            // If no more endpoints then break out.
            if(pEndpointDescriptor == 0)
            {
                break;
            }
            UARTprintf("pEndpointDescriptor details:\n");
            UARTprintf(" bLength=0x%02X (shall be 0x07)\n", pEndpointDescriptor->bLength);
            UARTprintf(" bDescriptorType=0x%02X\n", pEndpointDescriptor->bDescriptorType);
            UARTprintf(" bEndpointAddress=0x%02X\n", pEndpointDescriptor->bEndpointAddress);
            UARTprintf(" bmAttributes=0x%02X (0x00=CTRL, 0x01=ISOC, 0x02=BULK, 0x03=INT\n", pEndpointDescriptor->bmAttributes);
            UARTprintf(" wMaxPacketSize=0x%04X\n", pEndpointDescriptor->wMaxPacketSize);
            UARTprintf(" bInterval=0x%04X\n", pEndpointDescriptor->bInterval);

            // See if this is a bulk endpoint.
            if((pEndpointDescriptor->bmAttributes & USB_EP_ATTR_TYPE_M) ==
                    USB_EP_ATTR_BULK)
            {
                // See if this is bulk IN or bulk OUT.
                if(pEndpointDescriptor->bEndpointAddress & USB_EP_DESC_IN)
                {
                    UARTprintf("Endpoint Bulk In alloc USB Pipe\n");
                    // Allocate the USB Pipe for this Bulk IN endpoint.
                    g_USBHANDROIDDevice.ulBulkInPipe = USBHCDPipeAllocSize(0, USBHCD_PIPE_BULK_IN_DMA,
                                                                           pDevice->ulAddress,
                                                                           pEndpointDescriptor->wMaxPacketSize,
                                                                           0);
                    // Configure the USB pipe as a Bulk IN endpoint.
                    USBHCDPipeConfig(g_USBHANDROIDDevice.ulBulkInPipe,
                                     pEndpointDescriptor->wMaxPacketSize,
                                     BULK_READ_TIMEOUT,
                                     (pEndpointDescriptor->bEndpointAddress &
                                     USB_EP_DESC_NUM_M));
                }
                else
                {
                    UARTprintf("Endpoint Bulk OUT alloc USB Pipe\n");
                    // Allocate the USB Pipe for this Bulk OUT endpoint.
                    g_USBHANDROIDDevice.ulBulkOutPipe = USBHCDPipeAllocSize(0, USBHCD_PIPE_BULK_OUT_DMA,
                                                                            pDevice->ulAddress,
                                                                            pEndpointDescriptor->wMaxPacketSize,
                                                                            0);
                    // Configure the USB pipe as a Bulk OUT endpoint.
                    USBHCDPipeConfig(g_USBHANDROIDDevice.ulBulkOutPipe,
                                     pEndpointDescriptor->wMaxPacketSize,
                                     BULK_WRITE_TIMEOUT,
                                     (pEndpointDescriptor->bEndpointAddress &
                                     USB_EP_DESC_NUM_M));
                }
            }
        }

        // If the callback exists, call it with an Open event.
        if(g_USBHANDROIDDevice.pfnCallback != 0)
        {
            g_USBHANDROIDDevice.pfnCallback((t_u32)&g_USBHANDROIDDevice,
            ANDROID_EVENT_OPEN, 0);
        }
        
        // Set Flag isConnected
        g_USBHANDROIDDevice.connected = true;
    } else 
    {
        UARTprintf("Found possible device. switching to serial mode Time=%d\n", g_ulSysTickCount);
        switchDevice(pDevice);
        
        // Set Flag isConnected
        g_USBHANDROIDDevice.connected = false;  
    }

    UARTprintf("\nEnd USBHANDROIDOpen Time=%d\n", g_ulSysTickCount);        
    // Return the only instance of this device.
    return(&g_USBHANDROIDDevice);
}