def __init__(self, serial=None, path=None): '''Constructor, the algorithm will connect to the first YKUSH found if a path or serial number is not provided''' self._devhandle = None self._firmware_major_version = None self._firmware_minor_version = None self._downstream_port_count = None #Alber3.2 add self._proudct_id self._proudct_id = None if path: # open the provided path if _usingHid: # blocking by default self._devhandle = hid.device() self._devhandle.open_path(path) else: # also blocking by default but ensure it is self._devhandle = hidapi.Device(path=path, blocking=True) else: # otherwise try to locate a device for device in hid_enumerate(0, 0): if device['vendor_id'] == YKUSH_USB_VID and device[ 'product_id'] in YKUSH_USB_PID_LIST: if serial is None or serial == device['serial_number']: #Alber3.1 3.2 object attribute for YKUSHXS self._proudct_id = device['product_id'] return self.__init__(path=device['path']) if self._devhandle is None: raise YKUSHNotFound()
def __find_device(self) -> hidapi.Device: """ find HID device and open it Raises: Exception: HIDGuardian detected Exception: No device detected Returns: hid.Device: returns opened controller device """ # TODO: detect connection mode, bluetooth has a bigger write buffer # TODO: implement multiple controllers working if sys.platform.startswith('win32'): import pydualsense.hidguardian as hidguardian if hidguardian.check_hide(): raise Exception('HIDGuardian detected. Delete the controller from HIDGuardian and restart PC to connect to controller') detected_device: hidapi.Device = None devices = hidapi.enumerate(vendor_id=0x054c) for device in devices: if device.vendor_id == 0x054c and device.product_id == 0x0CE6: detected_device = device if detected_device == None: raise Exception('No device detected') dual_sense = hidapi.Device(vendor_id=detected_device.vendor_id, product_id=detected_device.product_id) return dual_sense
def __init__(self, vendor_id=0x10c4, product_id=0x8468, timeout_ms=1000, data=b'', debug=False): self.debug = debug self.data = data self.hd = None if (not self.data): self.timeout_ms = timeout_ms deviceInfo = next( hidapi.enumerate(vendor_id=vendor_id, product_id=product_id)) self.hd = hidapi.Device(info=deviceInfo) self.generator = self._generator() first_chunk = next(self.generator) init_ok = int.from_bytes(self.get_field("init_ok"), byteorder='big') if (init_ok != 0x55aa): raise RuntimeError( "Incorrect device ROM magic number (is %04x, should be 55aa). Try again without re-connecting the device. If the error persists, this software is not meant to be used with your device." % (init_ok)) self.model = int.from_bytes(self.get_field("model"), byteorder='big') if (self.model != 0x0201): raise RuntimeError("Unknown model number.") self.id = self.get_field("ID") self.id_str = binascii.hexlify(self.id).decode("ascii") self.settings = self.get_field("settings") #self.current_interval_seconds = int.from_bytes(self.settings[1:3], byteorder='big') # not actually used anywhere – measurement series store the interval they were recorded at # TODO: move this offset into memory_map? if (self.settings[0] != 0x2d or self.settings[3:] != binascii.unhexlify('006414')): sys.stderr.write( "WARNING: Unknown settings detected (only 24h format with degrees celsius was tested). Expect havoc.\n" )
def __init__(self): devices = tuple( hidapi.enumerate(vendor_id=self.vendor_id, product_id=self.product_id)) if not devices: raise DeviceNotFound() # keyboard subdevice kbd_info = next(filter(lambda x: x.interface_number == 1, devices), None) # control subdevice ctl_info = next(filter(lambda x: x.interface_number == 2, devices), None) self._kbd = hidapi.Device(kbd_info) self._ctl = hidapi.Device(ctl_info)
def _find_devices(self): for candidate in hidapi.enumerate(): try: dev = hidapi.Device(candidate, blocking=False) except IOError: raise DeviceException("Could not open HID device, please check" " your permissions on /dev/bus/usb.") yield dev
def __init__(self): logger.debug('searching for device {}'.format(self.__class__.info())) devices = tuple( hidapi.enumerate(vendor_id=self.vendor_id, product_id=self.product_id)) if len(devices): logger.debug('found {} subdevices:'.format(len(devices))) for device in devices: # print(device) # print(dir(device)) # x = 'interface_number', 'manufacturer_string', 'path', 'product_id', 'product_string', 'release_number', 'serial_number', 'usage', 'usage_page', 'vendor_id' # for i in x: # print(i, getattr(device, i)) interface = '' if device.interface_number == self.keyboard_interface: interface = ' [using as keyboard]' elif device.interface_number == self.control_interface: interface = ' [using as control]' logger.debug('{}: {} {} interface {}{}'.format( device.path.decode(), device.manufacturer_string, device.product_string, device.interface_number, interface)) else: logger.debug('0 devices found') if not devices: raise DeviceNotFound() # keyboard subdevice kbd_info = next( filter(lambda x: x.interface_number == self.keyboard_interface, devices), None) # control subdevice ctl_info = next( filter(lambda x: x.interface_number == self.control_interface, devices), None) logger.debug('opening keyboard subdevice') self._kbd = hidapi.Device(kbd_info) logger.debug('opening control subdevice') self._ctl = hidapi.Device(ctl_info)
def _ensure_open(self) -> bool: try: if self._dev is None: self._dev = hidapi.Device(self._devinfo, blocking=False) except Exception as err: self.logger.exception("Failed to open connection", exc_info=err) return False return True
def main(): for dev_info in hidapi.enumerate(vendor_id=0x413d, product_id=0x2107): if(dev_info.interface_number != 1): continue dev = hidapi.Device(info=dev_info) dev.write(b'\x01\x80\x33\x01\x00\x00\x00\x00') temp_raw = dev.read(8) dev.close() print(dump_to_temperature(temp_raw[2:4])) exit(0) print('No temper thermometer found') exit(1)
def _find_devices(self): """ Find all attached USB HID devices. :returns: All devices found :rtype: Generator that yields :py:class:`hidapi.Device` """ for candidate in hidapi.enumerate(): try: dev = hidapi.Device(candidate, blocking=False) except IOError: raise DeviceException("Could not open HID device, please check" " your permissions on /dev/bus/usb.") yield dev
def __init__(self, vendor_id=0x04d8, product_id=0xef7e, product_string=u'HoloPlay'): for dev in hidapi.enumerate(vendor_id=vendor_id, product_id=product_id): if dev.product_string == product_string: self.hiddev = hidapi.Device(dev) self.calibration = self.loadconfig() self.calculate_derived() break else: raise IOError("Looking Glass HID device not found")
def __init__(self, conntype='usb'): self.pdstate = 0 self.redcurrent = 0x08 self.ircurrent = 0x10 self.rawred = 0 self.redw = 0.0 self.redv = 0.0 self.red = 0.0 self.redsum = 0.0 self.rawir = 0 self.irw = 0.0 self.irv = 0.0 self.ir = 0.0 self.irsum = 0.0 self.redbuf = numpy.zeros(self.AVGSIZE, dtype=int) self.irbuf = numpy.zeros(self.AVGSIZE, dtype=int) self.bufidx = 0 self.pulse = False self.i2c = None self.usb = None if conntype == 'i2c': try: self.i2c = SMBus(1) self.set_reg(self.MODE_CONF, 0x40) time.sleep(0.01) self.set_reg(self.MODE_CONF, 0x03) self.set_reg(self.SPO2_CONF, ((0x00 << 5) | (0x01 << 2) | 0x03)) self.set_currents() self.set_reg(self.TEMP_CONF, 0x01) except: print "Heartbeat I2C sensor failed" self.i2c = None if conntype == 'usb': try: for dev in hidapi.enumerate(self.USB_VENDORID, self.USB_PRODUCTID): print "Checking %s" % (dev.path) if dev.manufacturer_string == self.USB_MANUFACTURER and dev.product_string == self.USB_PRODUCT: self.usb = hidapi.Device(path=dev.path) except: self.usb = None if not self.usb: print "Heartbeat USB sensor failed"
def main(): device = hidapi.Device(0x16c0, 0x27dc) # check serialNumber device.set_nonblocking(1) while True: # ret2 = device.get_feature_report(0, 8) ret2 = device.read(8) sys.stderr.write(repr(ret2) + '\r') ret = [] for i, r in enumerate(ret2): if i >= 2: ret.append((~ord(r)) & 0xFF) else: ret.append(ord(r)) # sys.stderr.write(' '.join(['%02x' % x for x in ret]) + ' | ' + ' '.join([bin(x, 8) for x in ret]) + '\r') # if ret[1] != 0x5A: # print 'error' time.sleep(0.05)
print("No widget") exit(-1) self.updateTemp(21.22) self.show() def updateTemp(self, temperature): self.temperatureWidget.display(temperature) # vid = 0x1eaf # Change it for your device pid = 0x24 # Change it for your device app = QtWidgets.QApplication(sys.argv) # bluepill = hidapi.Device(None, None, vid, pid, None, True) if (bluepill is None): QMessageBox.about(None, "Error", "Sensor not found") exit(-1) ui = tempUI() # rep = bytes(1) length_id = 2 round = 0 while True: print("Read " + str(round)) round = round + 1 out = bluepill.read(8, 1000, True) if (out is not None): temp = out[0] * 1000 + out[1] * 100 + out[2] * 10 + out[3] temp = temp / 100.
#!/usr/bin/env python import time, sys import hidapi devpath = None for d in hidapi.enumerate(0x16c0, 0x05df): if d.manufacturer_string == 'monsuwe.nl' and d.product_string == 'HeartMonitor': devpath = d.path if not devpath: raise "No device found" dev = hidapi.Device(path=devpath) print "%s %s" % (dev.get_manufacturer_string(), dev.get_product_string()) while True: values = map(ord, dev.get_feature_report(chr(0), (6 * 8) + 2)) if values: errstate = values[0] nums = values[1] #print "Err: %02x Nums: %02x" % (errstate, nums) for sn in range(0, nums): red = (values[sn * 6 + 2] * 256 + values[sn * 6 + 3]) * 256 + values[sn * 6 + 4] ird = (values[sn * 6 + 5] * 256 + values[sn * 6 + 6]) * 256 + values[sn * 6 + 7] print "Red: %10d IR: %10d" % (red, ird) time.sleep(0.02)
# the timestamp, gyro and accelerometer values. import hidapi import struct from sys import version_info if version_info[0] < 3: import six time2 = 0 Sensor = None # Use the first HID interface of the PSVR device_list = hidapi.enumerate(0x054c, 0x09af) for device_info in device_list: Sensor = hidapi.Device(device_info) break while Sensor: data = Sensor.read(64) if data == None: continue (time1, ) = struct.unpack("<I", data[16:20]) if time1 < time2: time2 = time2 - (1 << 24) print("Time-Slot1:", time1, time1 - time2) print("Gyros:", struct.unpack("<hhh", data[20:26])) print("Accel:", struct.unpack("<hhh", data[26:32])) print("-")
def open_joycons(lefts, rights): return ([hidapi.Device(d) for d in lefts], [hidapi.Device(d) for d in rights])
def Connect(self): self.dev = hid.Device(vendor_id=self.vendorID, product_id=self.productID, serial_number=self.serial)
def __init__(self): self.dev = hid.Device(vendor_id=self.vendorID, product_id=self.productID, serial_number=self.serial) self.state = 'stop'
def read_eeprom(devinfo): dev = hidapi.Device(devinfo) cfg = json.loads(loadconfig(dev).decode('ascii')) pprint(cfg) # TODO: Use calibration data. Sample code in lgdisplaytest.py return (dev, cfg)
print("Used HIDAPI lib: " + hidapi.lib) mode = "device" if (len(sys.argv) == 3): if (sys.argv[1] in ["dump", "read"]): mode = sys.argv[1] else: raise RuntimeError("Unknown command-line arguments.") data = None # TODO: in device mode, data should be supplied by a generator, lazily reading on-demand only if (mode in ["device", "dump"]): if "hidapi-libusb" in hidapi.lib: deviceInfo = next( hidapi.enumerate(vendor_id=vendor_id, product_id=product_id)) hd = hidapi.Device(info=deviceInfo) else: deviceInfo = next( hidapi.enumerate(vendor_id=vendor_id, product_id=product_id)) hd = hidapi.Device(info=deviceInfo) data = create_dump(hd) if (mode == "dump"): with open(sys.argv[2], 'wb') as f: f.write(data) else: data = open(sys.argv[2], 'rb').read() init_ok = int.from_bytes(get_field(data, "init_ok"), byteorder='big') if (init_ok != 0x55aa): raise RuntimeError( "Incorrect device ROM magic number (is %04x, should be 55aa). This software is not meant to be used with your device."