def profileusb(self, other):
del other
dev = find(find_all=True)
devices = []
for cfg in dev:
devclass = str(cfg.bDeviceClass)
product = str(cfg.iProduct)
vid = hex(cfg.idVendor)
pid = hex(cfg.idProduct)
for line in Configuration(find(idVendor=cfg.idVendor)):
line = str(line)
linestrip = line.strip()
linesplit = linestrip.split('\n')
linesplit = [x.split(':') for x in linesplit]
lines = []
for w in linesplit:
lines.append([y.strip(' ') for y in w])
for e in lines:
if 'bInterfaceClass' in e[0]:
intclass = e[1]
devices.append([devclass, product, vid, pid, intclass])
with open('devices.pkl', 'wb') as f:
dump(devices, f)
self.profile.SetLabel("Done!")
self.profile.Disable()
self.test.Enable()
def open(self, vendor=None, product=None):
if vendor is not None and product is not None:
dev = ucore.find(idVendor=vendor, idProduct=product)
else:
def match(d):
return (d.idVendor, d.idProduct) in supported_devices
dev = ucore.find(custom_match=match)
self.open_dev(dev)
def testusb(self, other):
del other
with open('devices.pkl', 'rb') as f:
benchmark = load(f)
dev = find(find_all=True)
devices = []
for cfg in dev:
devclass = str(cfg.bDeviceClass)
product = str(cfg.iProduct)
vid = hex(cfg.idVendor)
pid = hex(cfg.idProduct)
for line in Configuration(find(idVendor=cfg.idVendor)):
line = str(line)
linestrip = line.strip()
linesplit = linestrip.split('\n')
linesplit = [x.split(':') for x in linesplit]
lines = []
for w in linesplit:
lines.append([y.strip(' ') for y in w])
for e in lines:
if 'bInterfaceClass' in e[0]:
intclass = e[1]
devices.append([devclass, product, vid, pid, intclass])
first_tuple_list = [tuple(lst) for lst in benchmark]
secnd_tuple_list = [tuple(lst) for lst in devices]
first_set = set(first_tuple_list)
secnd_set = set(secnd_tuple_list)
output = ""
height = 100
first = 0
for devclass, product, vid, pid, usbtype in first_set.symmetric_difference(
secnd_set):
if usbtype == "0xa CDC Data":
devicedesc = "Virtual Data Port (Network)"
elif usbtype == "0xe0 Wireless Controller":
devicedesc = "Wireless Internet Or Bluetooth"
elif usbtype == "0x8 Mass Storage":
devicedesc = "Data Storage Device"
elif usbtype == "0x9 Hub":
devicedesc = "USB Hub"
elif usbtype == "0x3 Human Interface Device":
devicedesc = "Keyboard, Mouse, or Other Input Device"
elif usbtype == "0x2 CDC Communication":
devicedesc = "Vitual Communications Port (Network)"
else:
devicedesc = usbtype + " device "
if first == 0:
output += "This appears to be a: \n " + devicedesc + " \n"
else:
output += " " + devicedesc + " \n"
height = height + 30
first = 1
self.SetSize((500, height))
self.message.SetLabel(output)
def PlhUSBConnection(tracker_id):
trck_init = None
try:
import usb.core as uc
# Check the idProduct using the usbdeview software, the idProduct is unique for each
# device and connection fails when is incorrect
# trck_init = uc.find(idVendor=0x0F44, idProduct=0x0003) [used in a different device]
trck_init = uc.find(idVendor=0x0F44, idProduct=0xEF12)
cfg = trck_init.get_active_configuration()
for i in cfg:
for x in i:
# TODO: try better code
x = x
trck_init.set_configuration()
endpoint = trck_init[0][(0, 0)][0]
if tracker_id == 2:
# Polhemus FASTRAK needs configurations first
# TODO: Check configurations to standardize initialization for all Polhemus devices
trck_init.write(0x02, "u")
trck_init.write(0x02, "F")
# First run to confirm that everything is working
trck_init.write(0x02, "P")
data = trck_init.read(endpoint.bEndpointAddress,
endpoint.wMaxPacketSize)
if not data:
trck_init = None
print('Could not connect to Polhemus USB without error.')
except:
print('Could not connect to Polhemus USB with error.')
return trck_init
def __init__(self, vi, pi, ledonly, relaisonly, reset):
self.ledonly = ledonly
self.relaisonly = relaisonly
self.index = 0
self.devices = []
devicesraw = find(idVendor=vi, idProduct=pi, find_all=True)
for dev in devicesraw:
dev.id = len(self.devices)
self.devices.append(dev)
for dev in self.devices:
if dev:
ep = dev[0].interfaces()[0].endpoints()[0]
intf = dev[0].interfaces()[0].bInterfaceNumber
if dev.is_kernel_driver_active(intf):
try:
dev.detach_kernel_driver(intf)
except USBError as e:
sys.exit('Could not detatch kernel driver:' + str(e))
try:
dev.set_configuration()
if reset:
dev.reset()
except USBError as e:
sys.exit('Could not set configuration:' + str(e))
dev.eaddr = ep.bEndpointAddress
while True:
result = self.bulk_transfer_from_device(6)
if result[0] == 0:
sleep(0.1)
else:
break
self.old_state = result
else:
print('No device connected')
def __init__(self, idVendor=0x2121, idProduct=0x2130, configuration=(0,0)):
self.status = ("Initializing", False)
import usb.core as usbcore
self.dev = usbcore.find(idVendor=idVendor, idProduct=idProduct)
import usb.backend.libusb0
backend = usb.backend.libusb0.get_backend(find_library=lambda x: r'./windows_dll/libusb0.dll')
self.dev = usb.core.find(idVendor=idVendor, idProduct=idProduct, backend=backend)
if self.dev:
self.dev.set_configuration()
self.cfg = self.dev.get_active_configuration()
self.inf = self.cfg[configuration]
self.endpoint_out = usb.util.find_descriptor(self.inf, custom_match = lambda e: usb.util.endpoint_direction(e.bEndpointAddress) == usb.util.ENDPOINT_OUT)
self.endpoint_in = usb.util.find_descriptor(self.inf, custom_match = lambda e: usb.util.endpoint_direction(e.bEndpointAddress) == usb.util.ENDPOINT_IN)
self.send(cnc_commands.cmd_init_1())
self.send(cnc_commands.cmd_init_2())
self.send(cnc_commands.cmd_init_3())
self.send(cnc_commands.cmd_init_4())
self.send(cnc_commands.cmd_init_5())
self.send(cnc_commands.cmd_init_6())
self.send(cnc_commands.cmd_init_7())
self.send(cnc_commands.cmd_init_8())
self.send(cnc_commands.cmd_init_9())
self.send(cnc_commands.cmd_init_10())
self.restore_config(r"./valves/VWR_Plate_Lid.json")
else:
raise Exception, "Can't find device with vendor %0d and product %0d!" % (idVendor, idProduct)
def detect_tablet():
try:
dev = core.find(idVendor=0x256c, idProduct=0x006e)
return True if dev is not None else False
except Exception as e:
print("An error has occurred upon detecting device: {}".format(e))
return False
def __init__(self):
LOG.debug('probing usb devices')
self.device = find(idVendor=OUTLET_USB_VENDOR_ID,
idProduct=OUTLET_USB_PRODUCT_ID)
LOG.info('found device: %r', self.device)
if not self.device:
raise USBError('cannot find USB device')
def PlhPatriot(self):
trck_init = None
try:
import sys
import usb.core as uc
# import usb.util as uu
trck_init = uc.find(idVendor=0x0F44, idProduct=0xEF12)
if not trck_init:
print 'Could not find Polhemus PATRIOT USB. Trying Polhemus ' \
'serial connection...'
trck_init = self.polhemus_serial(3)
else:
try:
cfg = trck_init.get_active_configuration()
for i in cfg:
for x in i:
# TODO: try better code
x = x
trck_init.set_configuration()
except uc.USBError as err:
dlg.TrackerNotConnected(3)
print 'Could not set configuration %s' % err
except ImportError:
print 'Import Error for Polhemus PATRIOT USB.'
trck_init = self.polhemus_serial(3)
return trck_init
def PlhUSBConnection(tracker_id):
trck_init = None
try:
import usb.core as uc
# Check the idProduct using the usbdeview software, the idProduct is unique for each
# device and connection fails when is incorrect
# trck_init = uc.find(idVendor=0x0F44, idProduct=0x0003) [used in a different device]
trck_init = uc.find(idVendor=0x0F44, idProduct=0xEF12)
cfg = trck_init.get_active_configuration()
for i in cfg:
for x in i:
# TODO: try better code
x = x
trck_init.set_configuration()
endpoint = trck_init[0][(0, 0)][0]
if tracker_id == 2:
# Polhemus FASTRAK needs configurations first
# TODO: Check configurations to standardize initialization for all Polhemus devices
trck_init.write(0x02, "u")
trck_init.write(0x02, "F")
# First run to confirm that everything is working
trck_init.write(0x02, "P")
data = trck_init.read(endpoint.bEndpointAddress,
endpoint.wMaxPacketSize)
if not data:
trck_init = None
print('Could not connect to Polhemus USB without error.')
except:
print('Could not connect to Polhemus USB with error.')
return trck_init
def find_usb_device(self, serial_number):
# return a usb_device
try:
all_devices = core.find(find_all=True, idVendor=0x2457)
found_device = False
for self.__usb_device in all_devices:
try:
self.__usb_device.set_configuration()
except core.USBError:
raise core.USBError(
"Could not configure the usb device in OceanOpticsDevice.find_usb_device()"
)
# since this is USB the device name and ocean optics protocol are implied from the productID
self.__ocean_optics_protocol = \
device_identity.get_ocean_optics_device_protocol(self.__usb_device.idProduct)
self.__device_name = device_identity.get_ocean_optics_device_name(
self.__usb_device.idProduct)
self.set_product_id_and_usb_endpoints(
self.__usb_device.idProduct)
self.__serial_number = self.__introspection_methods.serial_number_get(
)
if serial_number == self.__serial_number:
found_device = True
break
except core.NoBackendError:
raise RuntimeError(
"Error: libusb is probably not installed on the host machine.\n{0}",
sys.exc_info()[0])
return found_device
def PlhPatriot(self):
trck_init = None
try:
import sys
import usb.core as uc
# import usb.util as uu
trck_init = uc.find(idVendor=0x0F44, idProduct=0xEF12)
if not trck_init:
print 'Could not find Polhemus PATRIOT USB. Trying Polhemus ' \
'serial connection...'
trck_init = self.polhemus_serial(3)
else:
try:
cfg = trck_init.get_active_configuration()
for i in cfg:
for x in i:
# TODO: try better code
x = x
trck_init.set_configuration()
except uc.USBError as err:
dlg.TrackerNotConnected(3)
print 'Could not set configuration %s' % err
except ImportError:
print 'Import Error for Polhemus PATRIOT USB.'
trck_init = self.polhemus_serial(3)
return trck_init
def PlhUSBConnection(tracker_id):
trck_init = None
try:
import usb.core as uc
trck_init = uc.find(idVendor=0x0F44, idProduct=0x0003)
cfg = trck_init.get_active_configuration()
for i in cfg:
for x in i:
# TODO: try better code
x = x
trck_init.set_configuration()
endpoint = trck_init[0][(0, 0)][0]
if tracker_id == 2:
# Polhemus FASTRAK needs configurations first
# TODO: Check configurations to standardize initialization for all Polhemus devices
trck_init.write(0x02, "u")
trck_init.write(0x02, "F")
# First run to confirm that everything is working
trck_init.write(0x02, "P")
data = trck_init.read(endpoint.bEndpointAddress,
endpoint.wMaxPacketSize)
if not data:
trck_init = None
except:
print 'Could not connect to Polhemus USB.'
return trck_init
def connect(self):
"""Attempt to and return connection"""
# Disconnect device if it's already connected.
if self._connected:
self.disconnect()
# Find the device by the vendor ID.
usb_device = core.find(idVendor=VENDOR_ID)
if not usb_device: # Device not found
return self._connected
# Copy the default configuration.
usb_device.set_configuration()
config = usb_device.get_active_configuration()
interface = config[(0, 0)]
# Get the write endpoint.
endpoint_out = util.find_descriptor(
interface,
custom_match=lambda e: util.endpoint_direction(
e.bEndpointAddress) == util.ENDPOINT_OUT)
assert endpoint_out is not None, 'cannot find write endpoint'
# Get the read endpoint.
endpoint_in = util.find_descriptor(
interface,
custom_match=lambda e: util.endpoint_direction(
e.bEndpointAddress) == util.ENDPOINT_IN)
assert endpoint_in is not None, 'cannot find read endpoint'
self._usb_device = usb_device
self._endpoint_in = endpoint_in
self._endpoint_out = endpoint_out
self._connected = True
return self._connected
def __plugDevice(flag, dom, usbmap):
for dev in core.find(find_all=True):
for cfg in dev:
intf = util.find_descriptor(cfg, find_all=True)
intf0 = util.find_descriptor(cfg, bInterfaceClass=0)
intf3 = util.find_descriptor(cfg, bInterfaceClass=3)
intf9 = util.find_descriptor(cfg, bInterfaceClass=9)
if intf != None and intf0 == None and intf3 == None and intf9 == None:
idVendor = str(hex(dev.idVendor))
if len(idVendor) < 6:
idVendor = '0x' + '0' * (6 - len(idVendor)) + idVendor[2:]
idProduct = str(hex(dev.idProduct))
if len(idProduct) < 6:
idProduct = '0x' + '0' * (6 - len(idProduct)) + idProduct[2:]
xml = __generateUSBXML(idVendor, idProduct)
if dom != None and dom.isActive() == True:
if flag:
dom.attachDevice(xml)
syspath=__getSysPath(idVendor, idProduct)
if syspath != None:
usbmap[syspath]=idProduct+idVendor
else:
dom.detachDevice(xml)
syspath=__getSysPath(idVendor, idProduct)
if syspath != None:
usbmap.pop(syspath)
else:
pass
def __init__(self):
super().__init__("IS-NITRO-Emulator")
self.device = find(idVendor=0x0F6e, idProduct=0x0404)
if self.device is None:
raise DeviceNotFound(self)
if self.debug:
self.print_configurations()
self.device.set_configuration()
# self.device.reset() # Prevent weird timeouts when used twice
config = self.device.get_active_configuration()
interface = config[(0, 0)]
# Claim interface
if self.device.is_kernel_driver_active(interface.iInterface):
self.device.detach_kernel_driver(interface.iInterface)
claim_interface(self.device, interface.iInterface)
self.endpoint_out = find_descriptor(interface,
bEndpointAddress=0x01) # Bulk Out
self.endpoint_in = find_descriptor(interface,
bEndpointAddress=0x82) # Bulk in
# self.endpoint_debug = find_descriptor(interface, bEndpointAddress=0x83) # Bulk in 2?
assert self.endpoint_out is not None
assert self.endpoint_in is not None
self.isid = resource_stream(__name__, "../resources/isid.bin").read()
self.debugger_code = resource_stream(
__name__, "../resources/debugger_code.bin").read()
def open_devpath(self, busnum: int, address: int):
def match(d):
return d.bus == busnum and d.address == address
dev = ucore.find(custom_match=match)
self.open_dev(dev)
def find_all_usb_devices():
device_list = list()
try:
all_devices = core.find(find_all=True, idVendor=0x2457)
for a_usb_device in all_devices:
try:
a_usb_device.set_configuration()
except core.USBError:
raise core.USBError(
"Could not configure the usb device in OceanOpticsDevice.find_usb_device()"
)
oo_protocol = device_identity.get_ocean_optics_device_protocol(
a_usb_device.idProduct)
oo_device_name = device_identity.get_ocean_optics_device_name(
a_usb_device.idProduct)
oo_device = OceanOpticsDevice(
interface_type=InterfaceType.USB,
product_id=a_usb_device.idProduct,
ocean_optics_protocol=oo_protocol,
ocean_optics_device_name=oo_device_name)
device_list.append(a_usb_device)
except core.NoBackendError:
raise RuntimeError(
"Error: libusb is probably not installed on the host machine.\n{0}",
sys.exc_info()[0])
return device_list
def listPrinters(self):
printers = core.find(find_all=True) # , bDeviceClass=7)
for printer in printers:
print printer.bDeviceClass
try:
print util.get_string(printer, 256, 3)
except:
print 'dispositivo oculto'
def __init__(self):
self.dev = u.find(idVendor=0x2123, idProduct=0x1010)
if self.dev is None:
raise IOError('Dream Cheeky missile launcher not found.')
if self.dev.is_kernel_driver_active(0):
self.dev.detach_kernel_driver(0)
self.dev.set_configuration()
print 'missile launcher initialized'
def enumerate_picoprobes(cls, uid=None) -> List["PicoLink"]:
"""! @brief Find and return all Picoprobes """
# Use a custom matcher to make sure the probe is a Picoprobe and accessible.
return [
PicoLink(probe)
for probe in core.find(find_all=True,
custom_match=FindPicoprobe(uid))
]
def _get_device_available(self, find=False):
"""Find the K85 and return True if it is connected"""
device = usb.find(idVendor=bVendor, idProduct=bProduct)
if device is None:
return False if find is False else None
if isinstance(device, list):
device = device[0]
return True if find is False else device
def usb_loop(self):
usb_devices = {}
devs = core.find(find_all=True)
for dev in devs:
path = "usb_%04x:%04x_%03d_%03d_" % (dev.idVendor, dev.idProduct, dev.bus, dev.address)
iot_device = IoTDevice(dev, 'usb')
usb_devices[path] = iot_device
return usb_devices
def test_find(self):
b = _MyBackend()
self.assertEqual(find(backend=b, idVendor=1), None)
self.assertNotEqual(find(backend=b, idProduct=1), None)
self.assertEqual(len(tuple(find(find_all=True, backend=b))),
len(b.devices))
self.assertEqual(
len(tuple(find(find_all=True, backend=b, idProduct=1))), 1)
self.assertEqual(
len(tuple(find(find_all=True, backend=b, idVendor=1))), 0)
self.assertEqual(
len(
tuple(
find(find_all=True,
backend=b,
custom_match=lambda d: d.idProduct == 1))), 1)
self.assertEqual(
len(
tuple(
find(
find_all=True,
backend=b,
custom_match=lambda d: d.idVendor == devinfo.ID_VENDOR,
idProduct=1))), 1)
def test_find(self):
b = _MyBackend()
self.assertEqual(find(backend=b, idVendor=1), None)
self.assertNotEqual(find(backend=b, idProduct=1), None)
self.assertEqual(len(find(find_all=True, backend=b)), len(b.devices))
self.assertEqual(len(find(find_all=True, backend=b, idProduct=1)), 1)
self.assertEqual(len(find(find_all=True, backend=b, idVendor=1)), 0)
self.assertEqual(
len(
find(
find_all=True,
backend=b,
custom_match = lambda d: d.idProduct==1
),
),
1
)
self.assertEqual(
len(
find(
find_all=True,
backend=b,
custom_match = lambda d: d.idVendor==devinfo.ID_VENDOR,
idProduct=1
),
),
1
)
def __init__(self):
# Connection to OWI Robotic Arm is established
self.OWIArmUsbDevice = usbdev.find(idVendor=vendor, idProduct=product)
if not self.OWIArmUsbDevice:
raise ValueError("Could not connect to OWI Robotic Arm.")
self.OWIArmUsbDevice.set_configuration()
# Initialize motors and light bulb to be in idle/resting state
self.stopMotion()
def checkcams(self):
self.devnums={"RGBtop":-1,"RGBside":-1,"Depth":-1}
self.videonodes={"RGBtop":-1,"RGBside":-1,"Depth":-1}
self.sidepresent=False
self.toppresent=False
self.depthpresent=False
rgbdev=list(usbcore.find(find_all=True,idVendor=_RGBid[0],idProduct=_RGBid[1]))
depthdev=list(usbcore.find(find_all=True,idVendor=_DEPTHid[0],idProduct=_DEPTHid[1]))
for d in rgbdev:
if d.port_number is _RGBTOPPORT:
self.devnums["RGBtop"]=d.address
elif d.port_number is _RGBSIDEPORT:
self.devnums["RGBside"]=d.address
for d in depthdev:
if d.port_number is _DEPTHPORT:
self.devnums["Depth"]=d.address
c = pyudev.Context()
for device in c.list_devices(subsystem='video4linux'):
try:
info=str(device).find("usb1")
port=int(str(device)[info+7])
node = int(str(device.device_node)[10:])
if (node!=0 and (node%2==0) and (port ==_RGBTOPPORT) and (self.devnums["RGBtop"] !=-1)):
self.videonodes["RGBtop"]=node
self.toppresent=True
elif (node!=0 and (node%2==0) and (port ==_RGBSIDEPORT) and (self.devnums["RGBside"] !=-1)):
self.videonodes["RGBside"] = node
self.sidepresent=True
except:
pass
if(self.devnums["Depth"] is not -1):
self.depthpresent=True
else:
self.depth_initialized=False
if(self.devnums["RGBtop"]) is not -1:
self.toppresent = True
else:
self.topinicialized = False
if (self.devnums["RGBside"]) is not -1:
self.sidepresent = True
else:
self.sideinicialized = False
def findExplorerDev():
# Get XBee Device File - for SparkFun XBee Explorer
# This could be done less cruftily
desc = core.find(idVendor=0x0403, idProduct=0x6015)
if desc is None:
return None
snum = desc.serial_number
prod = 'FTDI_FT231X_USB_UART'
dev = '/dev/serial/by-id/usb-{}_{}-if00-port0'.format(prod, snum)
return dev
def _open(self) -> None:
print('USB OPEN START')
try:
# find the first USB device that matches the filter
self._dev = find(idVendor=self._idVendor,
idProduct=self._idProduct)
if self._dev is None:
raise DriverException("Could not open specified device")
# Detach kernel driver
try:
if self._dev.is_kernel_driver_active(0):
try:
self._dev.detach_kernel_driver(0)
except USBError as e:
raise DriverException("Could not detach kernel driver")
except NotImplementedError:
pass # for non unix systems
# set the active configuration. With no arguments, the first
# configuration will be the active one
self._dev.set_configuration()
# get an endpoint instance
cfg = self._dev.get_active_configuration()
self._interfaceNumber = cfg[(0, 0)].bInterfaceNumber
interface = find_descriptor(cfg,
bInterfaceNumber=self._interfaceNumber,
bAlternateSetting=get_interface(
self._dev, self._interfaceNumber))
claim_interface(self._dev, self._interfaceNumber)
self._epOut = find_descriptor(
interface,
custom_match=lambda e: endpoint_direction(e.bEndpointAddress
) == ENDPOINT_OUT)
self._epIn = find_descriptor(
interface,
custom_match=lambda e: endpoint_direction(e.bEndpointAddress
) == ENDPOINT_IN)
if self._epOut is None or self._epIn is None:
raise DriverException("Could not initialize USB endpoint")
self._queue = Queue()
self._loop = self.USBLoop(self._epIn, self._packetSize,
self._queue)
self._loop.start()
self._driver_open = True
print('USB OPEN SUCCESS')
except IOError as e:
self._close()
raise DriverException(str(e))
def is_ai_cam_connected(self) -> List[str]:
"""Check if camera connected
:return: list of connected camera devices
:rtype: String list
"""
ai_cam_id_vendor = 0x0c45
ai_cam_id_product = 0x6366
dev = core.find(idVendor=ai_cam_id_vendor, idProduct=ai_cam_id_product)
return dev
def __init__(self):
#print "Init'ing RobotArm"
self.first = 1
#print self.first
self.device = usbdev.find(idVendor=VENDOR, idProduct=PRODUCT)
if(not self.device):
raise ValueError("Could not connect to Robotic Arm USB device. Is the arm connected properly? Perhaps you're not running as root?")
self.device.set_configuration()
self.reset()
def get_devices(products=(MSISPM_OLD, SISPM, MSISPM_FLASH, MSISPM_FLASH_NEW)):
"""
Returns a generator of Gembird USB outlet devices.
`products` defaults to a tuple of known working Gembird device identifiers.
Override products with caution, the usb commands might destroy a wrong device.
NOTE: You need appropriate user permissions to access the devices.
"""
for device in find(idVendor=VENDOR, find_all=True):
if device.idProduct in products:
yield OutletDevice(device)
def find_all(cls):
"""return all devices with this idVendor and idProduct"""
devices = []
try:
for device in _usb.find(idVendor=cls.ID_VENDOR,
idProduct=cls.ID_PRODUCT,
find_all=True):
devices.append(cls(device))
except _usb.NoBackendError as err:
raise StlinkComException("USB Error: %s" % err)
return devices
def openPort(Vid, Pid, ifc):
global dev
# Find glove
dev = core.find(idVendor=Vid, idProduct=Pid)
# Return if glove isn't found
if dev is None:
return None
# Claim interface
if dev.is_kernel_driver_active(ifc) is True:
dev.detach_kernel_driver(ifc)
util.claim_interface(dev, ifc)
return 0
def _initDevice():
"""Finds a Microchip PICDEM, which is what the lightmeter identifies as,
sadly. Not robust, but I can see no better way."""
lightmeterParams = {
'idVendor': 0x04d8,
'idProduct': 0xfcb7,
'configuration': 1,
'interface': (0, 0),
'reqLen': 64
}
# find our device
dev = usb.find(idVendor=lightmeterParams['idVendor'],
idProduct=lightmeterParams['idProduct'])
# was it found?
if dev is None:
raise RuntimeError('Device not found')
# set the active configuration. With no arguments, the first
# configuration will be the active one
try:
dev.set_configuration(lightmeterParams['configuration'])
except usb.USBError as e:
# if there are permission problems, this is where they manifest;
# attach the bus and address so that outer code can print an
# informative message.
e.bus = dev.bus
e.address = dev.address
raise e
# get an endpoint instance
cfg = dev.get_active_configuration()
intf = cfg[lightmeterParams['interface']]
endpointOut = util.find_descriptor(
intf,
# match the first OUT endpoint
custom_match = lambda e: \
usb.util.endpoint_direction(e.bEndpointAddress) \
== util.ENDPOINT_OUT)
endpointIn = util.find_descriptor(
intf,
# match the first IN endpoint
custom_match = lambda e: \
usb.util.endpoint_direction(e.bEndpointAddress) \
== util.ENDPOINT_IN)
if endpointOut is None or endpointIn is None:
raise RuntimeError('Unable to open endpoints')
return endpointIn, endpointOut
def enumerate_picoprobes(cls, uid=None) -> List["PicoLink"]:
"""! @brief Find and return all Picoprobes """
try:
# Use a custom matcher to make sure the probe is a Picoprobe and accessible.
return [
PicoLink(probe)
for probe in core.find(find_all=True,
custom_match=FindPicoprobe(uid))
]
except core.NoBackendError:
show_no_libusb_warning()
return []
def selectDevice():
devices = [d for d in usb.find(find_all=True)
if d.bDeviceClass in {0, 2, 0xff}]
if not devices:
print("No devices detected")
return None
selection = -1
selected = False
print("PyUSB VCP Terminal: use ctrl+c or ctrl+d to exit")
while not selected:
for i, d in enumerate(devices):
try:
manufacturer = d.manufacturer + " "
except:
manufacturer = "Unknown"
try:
prod = d.product + " "
except:
prod = ""
try:
serial = d.serial_number + " "
except:
serial = ""
print(
"%d: %04x:%04x on Bus %03d %03d %s%s%s" %
(i,
d.idVendor,
d.idProduct,
d.bus,
d.address,
manufacturer,
prod,
serial))
selection = input("Enter device: ")
try:
selection = int(selection)
if selection < 0 or selection >= len(devices):
raise Exception()
selected = True
except:
print(
"Please enter number between 0 and {}".format(
len(devices) - 1))
d = devices[selection]
return d
def get_device_handle():
dev = core.find(idVendor=VENDOR_ID, idProduct=PRODUCT_ID)
if dev is None:
raise SystemError("Device not found!")
interface = 0 # HID
# Free red button from kernel driver
# This does not work on OSX
if dev.is_kernel_driver_active(interface) is True:
dev.detach_kernel_driver(interface)
util.claim_interface(dev, interface)
kernel_was_attached = True
return dev
def update(self):
"""
updates pendrive list if, for example
a new pendrive is entered
"""
self.__pen_list = []
devices = core.find(find_all=True, bDeviceClass=0)
for device in devices:
cfg = device.get_active_configuration()
interface_class = cfg[(0,0)].bInterfaceClass
if interface_class == 8:
name = self.__getName(device)
ID = self.__getDeviceID(device)
usbDevice = USBDevice(device,name,ID)
self.__pen_list.append(usbDevice)
def isPassthroughUsbDevice(interfaceClass, idP, idV):
for dev in core.find(find_all=True):
for cfg in dev:
intf = util.find_descriptor(cfg, bInterfaceClass=interfaceClass)
if intf is not None:
idVendor = str(hex(dev.idVendor))
if len(idVendor) < 6:
idVendor = '0x' + '0' * (6 - len(idVendor)) + idVendor[2:]
idProduct = str(hex(dev.idProduct))
if len(idProduct) < 6:
idProduct = '0x' + '0' * (6 - len(idProduct)) + idProduct[2:]
if idVendor !=None and idProduct != None and idVendor == idV and idProduct == idP:
return True
return False
def selectDevice( ):
devices = list( usb.find( find_all=True ) )
if len( devices ) == 0:
print( "No devices detected" )
return None
selection = -1
selected = False
print( "PyUSB VCP Terminal: use ctrl+c or ctrl+d to exit" )
while not selected:
for i,d in enumerate( devices ):
try:
manufacturer = d.manufacturer
except:
manufacturer = "Unknown"
print( "%d: %04x:%04x on Bus %03d Address %03d %s" % (i, d.idVendor,
d.idProduct, d.bus, d.address, manufacturer) )
selection = input( "Enter device: " )
try:
selection = int( selection )
if selection < 0 or selection >= len(devices):
raise Exception()
selected = True
except:
print( "Please enter number between 0 and {}".format(len(devices) - 1) )
#try:
d = devices[selection]
#except Exception as e:
# log.error("Cannot open com port for {}".format(str(d)))
# print(str(e))
# exit()
return d
def lsdetect(color='ffffff', log_level='info', verbosity='simple'):
"""
Alienware detection tool for the masses.
Use this to find out your led addresses.
"""
set_log_level(log_level)
set_log_formatter(verbosity)
try:
machine = get_machine()
logger.info('Detected %s', machine['name'])
device = machine['device']
product_id = machine['uid']
except EnvironmentError:
logger.info('Cannot find machine')
product_id = None
while product_id is None:
try:
product_id = int(read_input('Product ID (ex: 0x0525): '), 16)
except ValueError:
pass
except KeyboardInterrupt:
logger.info('kthxbye')
return SUCCESS
device = find(idVendor=VENDOR_ID, idProduct=product_id)
if device is None:
return log_error_code(ERROR_DEVICE_NOT_FOUND)
try:
# This is the first step, we need to take control of the detected
# device. We try really hard to connect, should be safe in most
# situations for most machines.
connect(device)
except USBError:
logger.error('Cannot take over device')
return log_error_code(ERROR_DEVICE_CANNOT_TAKE_OVER)
try:
wait_ok(device)
except USBError:
return log_error_code(ERROR_DEVICE_TIMEOUT)
idx = 0
print ('Shutting down all leds, remember to use your touchpad '
'so you can acknowledge when its lights turns on.')
try:
cmd_reset(device, RESET_ALL_LIGHTS_OFF)
wait_ok(device)
cmd_reset(device, RESET_ALL_LIGHTS_ON)
except USBError:
return log_error_code(ERROR_DEVICE_TIMEOUT)
machine_name = read_input("Machine name: ")
mode_version = 'MODE_VERSION_1'
try:
color = parse_color(color)
idx = 0
detected = []
for address in LEDS_TO_SCAN:
logger.info('Trying led 0x%.4x', address)
try:
wait_ok(device)
cmd_set_color(device, idx, address, color)
cmd_end_loop(device)
cmd_transmit_execute(device)
except USBError:
return log_error_code(ERROR_DEVICE_TIMEOUT)
changed = y_or_n('Did some led turned on? (y/[n]): ')
if changed:
name = read_input('Describe it (ex: Middle Left Keyboard)?: ')
idx += 1
detected.append((address, name))
if not y_or_n('Does your machine use leds when sleeping on battery? '
'[Newer Alienware devices don\'t. '
'Answer "n" if you are not sure] (y/[n]): '):
mode_version = 'MODE_VERSION_2'
except KeyboardInterrupt:
print ('')
finally:
print ('')
print ('# Autogenerated machine definition:')
print ('defmachine(0x%.4x, "%s", ( ' % (product_id, machine_name))
for zone in detected:
address, name = zone
print (' defzone(0x%.4x, "%s"),' % (address, name))
print ('), %s)' % mode_version)
return SUCCESS
def createMicro(cls):
snum = core.find(idVendor=0x1ffb, idProduct=0x0089).serial_number
prod = 'Pololu_Corporation_Pololu_Micro_Maestro_6-Servo_Controller'
# if00 is command port, if02 control port
dev = '/dev/serial/by-id/usb-{}_{}-if00'.format(prod, snum)
return cls(dev)
def __init__(self):
self.dirname = ''
self.location = 0
self.devices = [Device(d) for d in core.find(find_all=True)]
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from usb.core import find
import usb.control
def is_mass_storage(dev):
import usb.util
for cfg in dev:
if usb.util.find_descriptor(cfg, bInterfaceClass=8) is not None:
return True
for mass in find(find_all=True, custom_match=is_mass_storage):
print(mass)
def busses():
r"""Returns a tuple with the usb busses."""
return (Bus(g) for k, g in groupby(
sorted(core.find(find_all=True), key=lambda d: d.bus),
lambda d: d.bus))
