def set_report(self,report_data,report_id=0): ''' "set" a report - send the data to the device (which must have been opened previously) ''' HIDDevice.set_report(self,report_data,report_id) report_buffer=(c_ubyte*(len(report_data)+1))() report_buffer[0]=report_id # first byte is report id for i,c in enumerate(report_data): report_buffer[i+1]=struct.unpack('B',c)[0] def completion_callback(dwErrorCode,dwNumberOfBytesTransfered,lpOverlapped): pass overlap_completion=LPOVERLAPPED_COMPLETION_ROUTINE(completion_callback) result=WriteFileEx( self._device_handle, report_buffer, len(report_buffer), self._write_overlapped, overlap_completion ) if not result: raise RuntimeError("WriteFileEx failed") if Kernel32.SleepEx(100,1) == 0: raise RuntimeError("timed out when writing to device")
def __init__(self, hidDevice, vendor, product): ''' create the hid device wrapper hidDevice is a handle from the OS ''' HIDDevice.__init__(self, vendor, product) self.IOObjectRelease = IOObjectRelease # need to hold onto reference to release function self._hidDevice = hidDevice self._hidInterface = None
def close(self): # make sure we stop the thread first HIDDevice.close(self) if self._device_handle: # re-import logging, as may have been deleted already import logging logging.info("closing _device_handle") self._CloseHandle(self._device_handle) self._device_handle=None self._write_overlapped=None
def set_report(self,report_data,report_id=0): ''' "set" a report - send the data to the device (which must have been opened previously) ''' HIDDevice.set_report(self,report_data,report_id) # copy data into a ctypes buffer report_buffer=(c_ubyte*len(report_data))() for i,c in enumerate(report_data): report_buffer[i]=struct.unpack('B',c)[0] ioret=self._devInterface.WritePipe(2, report_buffer, len(report_data)) if ioret != kIOReturnSuccess: logging.info("error writing to device: 0x%x" % long(ioret))
def open_device(info): if HID_INTERFACE == 'hid': return HIDDevice(path=info['path']) elif HID_INTERFACE == 'hidapi': device = hid.device() device.open_path(info['path']) return device
def set_report(self,report_data,report_id=0): ''' "set" a report - send the data to the device (which must have been opened previously) ''' HIDDevice.set_report(self,report_data,report_id) # copy data into a ctypes buffer report_buffer=(c_ubyte*len(report_data))() for i,c in enumerate(report_data): report_buffer[i]=struct.unpack('B',c)[0] self._hidInterface.setReport( kIOHIDReportTypeOutput, report_id, report_buffer, len(report_buffer), 100, # 100ms IOHIDReportCallbackFunction(), None, None # NULL callback )
def _open_dev(self) -> bool: vendor_id = 0x22b8 product_id = 0x7f01 self.device = device = HIDDevice() try: device.open(vendor_id, product_id) mfr = device.get_manufacturer_string() prd = device.get_product_string() ser = device.get_serial_number_string().encode() if mfr == "Giant Wireless Technology" and prd == "MX240a MOTOROLA MESSENGER" and ser == b"\xd0\x89": return True except IOError: pass return False
def open(self) -> None: logger.debug("Opening device...") self.device = device = HIDDevice() try: device.open(0x22b8, 0x7f01) mfr = device.get_manufacturer_string() prd = device.get_product_string() ser = device.get_serial_number_string().encode() if mfr != "Giant Wireless Technology" or prd != "MX240a MOTOROLA MESSENGER" or ser != b"\xd0\x89": raise IOError() except IOError: logger.error("Error opening device") exit(1) logger.trace(f"mfr: {device.get_manufacturer_string()}") logger.trace(f"prd: {device.get_product_string()}") logger.trace( f"ser: {to_hex(device.get_serial_number_string().encode())}") self.read_thread.start() self.write_thread.start() logger.debug("Initializing...") self.write(b"\xad\xef\x8d\xff") packet: Optional[Packet] try: packet = self.packet_buffer.get(timeout=0.5) except queue.Empty: packet = None if not packet: logger.trace("Init reply skipped for some reason?") elif packet.packet_type == PacketType.BaseInitReply: logger.trace("Init reply: {}", packet) else: logger.warning( "Reading real data, you might want to restart the driver") logger.debug("Init complete") self.process_thread.start() self.poll_thread.start()
def __init__(self,device_path,vendor,product): HIDDevice.__init__(self,vendor,product) self._device_path=device_path self._device_handle=None self._CloseHandle=Kernel32.CloseHandle
def close(self): # should be sufficient to get callback thread to quit if self._hidInterface: self._hidInterface = None HIDDevice.close(self)
def __del__(self): HIDDevice.__del__(self) if self._hidDevice: logging.info("releasing HID device: %s" % self) self.IOObjectRelease(self._hidDevice)