Example #1
0
 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")
Example #2
0
 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
Example #3
0
 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
Example #4
0
 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
Example #5
0
    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))
Example #6
0
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
Example #7
0
 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
     )
Example #8
0
 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
     )
Example #9
0
    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
Example #10
0
    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()
Example #11
0
 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
Example #12
0
 def close(self):
     # should be sufficient to get callback thread to quit
     if self._hidInterface:
         self._hidInterface = None
     HIDDevice.close(self)
Example #13
0
 def __del__(self):
     HIDDevice.__del__(self)
     if self._hidDevice:
         logging.info("releasing HID device: %s" % self)
         self.IOObjectRelease(self._hidDevice)
Example #14
0
 def close(self):
     # should be sufficient to get callback thread to quit
     if self._hidInterface:
         self._hidInterface = None
     HIDDevice.close(self)
Example #15
0
 def __del__(self):
     HIDDevice.__del__(self)
     if self._hidDevice:
         logging.info("releasing HID device: %s" % self)
         self.IOObjectRelease(self._hidDevice)