def _load_usb_backend(): # First try to find backend locally, if not found try the systems. try: tmp = os.environ['PATH'] os.environ['PATH'] = '' backend = libusb1.get_backend(find_library=_find_library_local) if backend is not None: return backend finally: os.environ['PATH'] = tmp backend = libusb1.get_backend() if backend is not None: return backend
def backend_init(): # Initialize backend global BACKEND BACKEND = libusb1.get_backend() if not BACKEND: # Set the libusb path if platform.system() in 'Windows': if '32bit' in str(platform.architecture()): LIBUSB_PATH = resource_path('libusb\\MS32\\libusb-1.0.dll') else: LIBUSB_PATH = resource_path('libusb\\MS64\\libusb-1.0.dll') BACKEND = libusb1.get_backend(find_library=lambda x: LIBUSB_PATH) if not BACKEND: sys_exit('No USB library found.')
def __init__(self): # attempt to find the PSoC plant electrophys device test = libusb1.get_backend() print test print 'test' self.device = usb.core.find(idVendor=VENDOR_ID, idProduct=PRODUCT_ID, backend=libusb1.get_backend()) if self.device is None: print ValueError("Device not found") else: logging.info("Device found") # set the active configuration, pyUSB handles the details self.device.set_configuration() logging.error("fix above") # set the different interfaces and endpoints of the device, see device API for documentation usb_config = self.device.get_active_configuration() # the communication is on the first interface (0) and the second alternate setting (1) communication_interface = usb_config[(0, 1)] self.ep_send_info = communication_interface[1] # the OUT endpoint is EP2 self.ep_get_info = communication_interface[0] # the IN endpoint is EP1 # the communication is on the first interface (0) and the third alternate setting (2) data_interface = usb_config[(0, 2)] self.ep_get_data = data_interface[0] # the IN endpoint for ISO data transfer is the 0 EP of interface 0,2 self.device.set_interface_altsetting(interface=0, alternate_setting=1)
def open(self, device=None): """ Opens the connection to the Sound Card. If no device is given, it will try to connect to the first Sound Card that is connected to the computer. :param device: (Optional) Already initialized libUSB's device to use. """ if device is None: self._backend = libusb.get_backend() try: self._dev = usb.core.find(backend=self._backend, idVendor=0x04d8, idProduct=0xee6a) except OSError as e: self._dev = None pass else: self._dev = device if self._dev is None: print( "Unable to connect to the Sound Card through the USB port. You will be unable to send and receive sounds." ) else: # set the active configuration. With no arguments, the first configuration will be the active one # note: some devices reset when setting an already selected configuration so we should check for it before self._cfg = self._dev.get_active_configuration() if self._cfg is None or self._cfg.bConfigurationValue != 1: self._dev.set_configuration(1) self._connected = True if self._dev else False
def open(self): if self._conn_open is True: return True print('Trying to open USB connection to the Harp sound card') backend = libusb.get_backend() # backend = libusb.get_backend(find_library=lambda x: "libusb-1.0.dll") self._dev = usb.core.find(backend=backend, idVendor=0x04d8, idProduct=0xee6a) if self._dev is None: print( f'\tError while trying to connect to the Harp sound card. Please make sure it is connected to the computer and try again.' ) return False print(f'backend used: {self._dev.backend}') if self._dev is None: print( '\tSoundCard not found. Please connect it to the USB port before proceeding.' ) else: # set the active configuration. With no arguments, the first configuration will be the active one # note: some devices reset when setting an already selected configuration so we should check for it before _cfg = self._dev.get_active_configuration() if _cfg is None or _cfg.bConfigurationValue != 1: self._dev.set_configuration(1) usb.util.claim_interface(self._dev, 0) self._conn_open = True return True
def get_possible_devices(self, idProduct=None, dictonly=True): """ Get a list of matching devices being based a list of PIDs. Returns list of usbdev that match (or empty if none) """ if idProduct is None: idProduct = [None] my_kwargs = {'find_all': True, 'idVendor': 0x2B3E} if os.name == "nt": #on windows, need to manually load libusb because of 64bit python loading the wrong one libusb_backend = libusb1.get_backend() if not libusb_backend: libusb_backend = libusb0.get_backend( find_library=lambda x: r"c:\Windows\System32\libusb0.dll") logging.info("Using libusb0 backend") my_kwargs['backend'] = libusb_backend devlist = [] try: for id in idProduct: if id: dev = list(usb.core.find(idProduct=id, **my_kwargs)) else: dev = list(usb.core.find(**my_kwargs)) if len(dev) > 0: if len(dev) == 1: devlist.extend(dev) else: # Deals with the multiple chipwhisperers attached but user only # has permission to access a subset. The langid error is usually # raised when there are improper permissions, so it is used to # skip the those devices. However, the user is warned when this # happens because the langid error is occasionally raised when # there are backend errors. for d in dev: try: d.serial_number devlist.append(d) except ValueError as e: if "langid" in str(e): logging.info( 'A device raised the "no langid" error, it is being skipped' ) else: raise if dictonly: devlist = [{ 'sn': d.serial_number, 'product': d.product, 'pid': d.idProduct, 'vid': d.idVendor } for d in devlist] return devlist except ValueError as e: if "langid" not in str(e): raise raise OSError( "Unable to communicate with found ChipWhisperer. Check that another process isn't connected to it and that you have permission to communicate with it." )
def get_storage_device(self): devices = list( usb.core.find(find_all=True, backend=libusb1.get_backend())) storage_device = [] device_list = self.__get_device_mount_point__( self.__get_mass_storage_devices__(devices)) for device in device_list: storage_device.append(StorageDevice(device)) return storage_device
def __init__(self, use_libusb0 = True): self.dev = usb.core.find(idVendor = 0X0456, idProduct = 0XB40D, backend = libusb0.get_backend() if use_libusb0 else libusb1.get_backend()) if self.dev is not None: self.dev.set_configuration() super().__init__(self.dev)
def findBEE(self): r""" findBEE method searches for connected printers and tries to connect to the first one. """ self.connected = False # find our device self.dev = usb.core.find(idVendor=0xFFFF, idProduct=0x014E, backend=libusb1.get_backend()) # self.dev = usb.core.find(idVendor=0xffff, idProduct=0x014e,backend=libusb0.get_backend()) # self.dev = usb.core.find(idVendor=0xffff, idProduct=0x014e,backend=openusb.get_backend()) # was it found? no, try the other device if self.dev is None: self.dev = usb.core.find(idVendor=0x29C9, idProduct=0x001) elif self.dev is None: raise ValueError("Device not found") if self.dev is None: print("Can't Find Printer") return # set the active configuration. With no arguments, the first # configuration will be the active one try: self.dev.set_configuration() self.dev.reset() self.cfg = self.dev.get_active_configuration() self.intf = self.cfg[(0, 0)] print("reconnect") except usb.core.USBError as e: sys.exit("Could not set configuration: %s" % str(e)) # self.endpoint = self.dev[0][(0,0)][0] self.ep_out = usb.util.find_descriptor( self.intf, # match the first OUT endpoint custom_match=lambda e: usb.util.endpoint_direction(e.bEndpointAddress) == usb.util.ENDPOINT_OUT, ) self.ep_in = usb.util.find_descriptor( self.intf, # match the first in endpoint custom_match=lambda e: usb.util.endpoint_direction(e.bEndpointAddress) == usb.util.ENDPOINT_IN, ) # Verify that the end points exist assert self.ep_out is not None assert self.ep_in is not None self.connected = True return
def load_libusb(): """Apply a patch to pyusb and load the libusb1 backend""" # Patch ctypes find_library to look in the correct location # import ctypes.util # ctypes.util.find_library = find_library # Patch the LibUSB init to disable device discovery from usb.backend import libusb1 libusb1._LibUSB.__init__ = libusb_init return libusb1.get_backend(find_library)
def find(bus, address): gs_usb = usb.core.find( idVendor=GS_USB_ID_VENDOR, idProduct=GS_USB_ID_PRODUCT, bus=bus, address=address, backend=libusb1.get_backend(), ) if gs_usb: return GsUsb(gs_usb) return None
def find_devices(vendor=None, product=None, serial_number=None, custom_match=None, **kwargs): """Find connected USB devices matching certain keywords. Wildcards can be used for vendor, product and serial_number. :param vendor: name or id of the vendor (manufacturer) :param product: name or id of the product :param serial_number: serial number. :param custom_match: callable returning True or False that takes a device as only input. :param kwargs: other properties to match. See usb.core.find :return: """ kwargs = kwargs or {} attrs = {} if isinstance(vendor, str): attrs["manufacturer"] = vendor elif vendor is not None: kwargs["idVendor"] = vendor if isinstance(product, str): attrs["product"] = product elif product is not None: kwargs["idProduct"] = product if serial_number: attrs["serial_number"] = str(serial_number) if attrs: def cm(dev): if custom_match is not None and not custom_match(dev): return False for attr, pattern in attrs.items(): try: value = getattr(dev, attr) except (NotImplementedError, ValueError): return False if not fnmatch(value.lower(), pattern.lower()): return False return True else: cm = custom_match ## ADDED THIS to make sure using libusb in this test example be = libusb1.get_backend() return usb.core.find(backend=be, find_all=True, custom_match=cm, **kwargs)
def scan(): r""" Retrieve the list of gs_usb devices handle :return: list of gs_usb devices handle """ return [ GsUsb(dev) for dev in usb.core.find( find_all=True, idVendor=GS_USB_ID_VENDOR, idProduct=GS_USB_ID_PRODUCT, backend=libusb1.get_backend(), ) ]
def device_from_fd(fd): import usb.backend.libusb1 as libusb1 backend = libusb1.get_backend() if not backend: raise NoBackendError('No backend available') dev = backend.get_device_from_fd(fd) # create device device = Device(dev, backend) device._ctx.handle = dev return device
def device_from_fd(fd): # setup library backend = libusb1.get_backend() lib = backend.lib ctx = backend.ctx # extend c wrapper with android functionality lib.libusb_wrap_sys_device.argtypes = [ libusb1.c_void_p, libusb1.c_int, libusb1.POINTER(libusb1._libusb_device_handle), ] lib.libusb_get_device.argtypes = [libusb1.c_void_p] lib.libusb_get_device.restype = libusb1._libusb_device_handle LOGGER.debug("usb fd: %s", fd) # get handle from file descriptor handle = libusb1._libusb_device_handle() libusb1._check(lib.libusb_wrap_sys_device(ctx, fd, libusb1.byref(handle))) LOGGER.debug("usb handle: %s", handle) # get device (id?) from handle devid = lib.libusb_get_device(handle) LOGGER.debug("usb devid: %s", devid) # device: devid + handle wrapper class DummyDevice: def __init__(self, devid, handle): self.devid = devid self.handle = handle dev = DummyDevice(devid, handle) # create pyusb device device = usb.core.Device(dev, backend) device._ctx.handle = dev # device.set_configuration() return device
def __init__(self, device=None): """ If a libUSB's device is given, it will try to open it. If none is given it will try to connect to the first Sound Card that is connected to the computer. :param device: (Optional) libUSB device to use. If nothing is passed, it will try to connect automatically. """ self._backend = libusb.get_backend() try: self._devices = list( usb.core.find(backend=self._backend, idVendor=0x04d8, idProduct=0xee6a, find_all=True)) except OSError as e: pass self._dev = self._devices[0] if self._devices else None self._cfg = None self._port = None self._connected = False self.open(self._dev if device is None else device)
import usb.backend.libusb1 as libusb1 import usb.util backend = libusb1.get_backend() if backend is None: raise ValueError('No backend available') for bus in usb.busses(): print(bus) for device in bus.devices: if device != None: usbDevice = usb.core.find(idVendor=device.idVendor, idProduct=device.idProduct) print(usbDevice)
def findBEE(self): r""" findBE-E method searches for connected printers and tries to connect to the first one. """ self.connected = False # find all devices that match BEEVC USB descriptors devices = [] d=usb.core.find(find_all=True, idVendor=0xffff, idProduct=0x014e, backend=libusb1.get_backend()) if d!=None: for a in d: devices.append(a) d=usb.core.find(find_all=True, idVendor=0x29c9, idProduct=0x0001, backend=libusb1.get_backend()) if d!=None: for a in d: devices.append(a) d=usb.core.find(find_all=True, idVendor=0x29c9, idProduct=0x0002, backend=libusb1.get_backend()) if d!=None: for a in d: devices.append(a) d=usb.core.find(find_all=True, idVendor=0x29c9, idProduct=0x0003, backend=libusb1.get_backend()) if d!=None: for a in d: devices.append(a) d=usb.core.find(find_all=True, idVendor=0x29c9, idProduct=0x0004, backend=libusb1.get_backend()) if d!=None: for a in d: devices.append(a) #print("DEVICES:", devices) # try to connect to each of the devices found connected=False for dev in devices: connected = False self.dev = dev # set the active configuration. With no arguments, the first # configuration will be the active one try: self.dev.set_configuration() self.dev.reset() time.sleep(0.5) #self.dev.set_configuration() self.cfg = self.dev.get_active_configuration() self.intf = self.cfg[(0,0)] print("reconnect") connected=True #if it reached this point witout throwing an exception, we are connected to an available device break #out of for loop except usb.core.USBError as e: #print("Could not set configuration: %s" % str(e)) connected=False # if it throws an expception we are not connected #time.sleep(1) #if iterating a big list it is a good idea to let it sleep for a while #self.endpoint = self.dev[0][(0,0)][0] if connected==False: sys.exit("ERROR: Unable to connect to a valid device.") else: #we are connected print("Connected to", self.dev.manufacturer, self.dev.product, "(SN:"+self.dev.serial_number+")") self.ep_out = usb.util.find_descriptor( self.intf, # match the first OUT endpoint custom_match = \ lambda e: \ usb.util.endpoint_direction(e.bEndpointAddress) == \ usb.util.ENDPOINT_OUT) self.ep_in = usb.util.find_descriptor( self.intf, # match the first in endpoint custom_match = \ lambda e: \ usb.util.endpoint_direction(e.bEndpointAddress) == \ usb.util.ENDPOINT_IN) # Verify that the end points exist assert self.ep_out is not None assert self.ep_in is not None self.connected = True return
__author__ = 'torresmateo' #!/usr/bin/python import sys import usb.core # find USB devices dev = usb.core.find(find_all=True) # loop through devices, printing vendor and product ids in decimal and hex for cfg in dev: print cfg.product sys.stdout.write('Decimal VendorID=' + str(cfg.idVendor) + ' & ProductID=' + str(cfg.idProduct) + '\n') sys.stdout.write('Hexadecimal VendorID=' + hex(cfg.idVendor) + ' & ProductID=' + hex(cfg.idProduct) + '\n\n') from usb.backend import libusb1 a = libusb1.get_backend() print a
def __init__(self, parent=None): QtCore.QThread.__init__(self, parent) self.backend = libusb1.get_backend() self.device_connected.connect(self.device_info_receive)
def __init__(self, idVendor=0x0451, idProduct=0xc900): self.dev=usb.core.find(idVendor=idVendor ,idProduct=idProduct, backend=libusb1.get_backend()) print(self.dev) self.dev.set_configuration() self.ans=[]