def pywinusb_read_values(): all_devices = hid.HidDeviceFilter().get_devices() if not all_devices: print("pywinusb can't find any non system HID device connected") return False else: for device in all_devices: try: device.open() usage_found = False for report in device.find_feature_reports(): target_usage = hid.get_full_usage_id(0xFFAB, 0x20) if target_usage in report: report.get() print("RPT DEBUG: {0}".format(report.get_raw_data())) usage_found = True target_usage = hid.get_full_usage_id(0x85, 0x66) if target_usage in report: report.get() print("RPT ID 0x08: {0}".format(report.get_raw_data())) usage_found = True target_usage = hid.get_full_usage_id(0x85, 0xD0) if target_usage in report: report.get() print("RPT ID 0x0B: {0}".format(report.get_raw_data())) usage_found = True finally: device.close() if not usage_found: print("pywinusb target device was found, but the requested usage does not exist!\n") return False return True
def retrieve_data(input_profile, db_file_path): global readings_values, profile, source_name reset_status() profile = input_profile target_vendor_id = 0x0590 target_usage = hid.get_full_usage_id(0xff00, 0x3) source_name = "OMRON M10-IT" read_values(target_usage, target_vendor_id, source_name) new_readings_inserted = db_update.update(db_file_path, readings_values) return new_readings_inserted
def __init__(self, name, hid_id, led_id, mappings, button_mapping, axis_scale=350.0): self.name = name self.hid_id = hid_id self.led_id = led_id self.mappings = mappings self.button_mapping = button_mapping self.axis_scale = axis_scale self.dict_state = {"button":0} self.tuple_state = SpaceNavigator(-1,0,0,0,0,0,0,0) # start in disconnected state self.device = None self.led_usage = hid.get_full_usage_id(self.led_id[0], self.led_id[1]) self.callback = None self.button_callback = None
def set_mute(mute_value): "Browse for mute usages and set value" all_mutes = ( \ (0x8, 0x9), # LED page (0x1, 0xA7), # desktop page (0xb, 0x2f), ) all_target_usages = [hid.get_full_usage_id(u[0], u[1]) for u in all_mutes] # usually you'll find and open the target device, here we'll browse for the # current connected devices all_devices = hid.find_all_hid_devices() success = 0 if not all_devices: print("Can't any HID device!") else: # search for our target usage # target pageId, usageId for device in all_devices: try: device.open() # target 'to set' value could be in feature or output reports for report in device.find_output_reports() + device.find_feature_reports(): for target_usage in all_target_usages: if target_usage in report: # set our value and send print("Found in report: {0}\n".format(report)) old_raw_data = report.get_raw_data() print(" Empty raw report: {0}".format(old_raw_data)) report[target_usage] = value new_raw_data = report.get_raw_data() print(" Set raw report: {0}\n".format(new_raw_data)) # validate that set_raw_data() is working properly report.set_raw_data( new_raw_data ) report.send() success += 1 finally: device.close() # fit to sys.exit() proper result values print("{0} Mute usage(s) set\n".format(success)) if success: return 0 return -1
# set ledblink x = [0x12, 0,0,0,0,0,0,0,0,0] for i in range(1): report[mbed_usage][i] = x[i] print 'sent: ', x report.send() # set aux on x = [0x31, 0,0,0,0,0,0,0,0,0] for i in range(1): report[mbed_usage][i] = x[i] print 'sent: ', x report.send() sleep(0.25) HIDdevice.close() sys.exit() except: print 'close' HIDdevice.close() if __name__ == '__main__': # The vendor ID used in the Mbed program mbed_vendor_id = 0x1234 # Vendor page and usage_id = 2 mbed_usage = hid.get_full_usage_id(0xffab, 0x02) # Search the Mbed, attach rx handler and send data findHIDDevice(mbed_usage, mbed_vendor_id)
import pywinusb.hid as hid def sample_handler(data): print("Raw data: {0}".format(data)) # VID and PID customization changes here... filter = hid.HidDeviceFilter(vendor_id = 0x03eb, product_id = 0x2402) hid_device = filter.get_devices() device = hid_device[0] device.open() print(hid_device) target_usage = hid.get_full_usage_id(0x00, 0x3f) device.set_raw_data_handler(sample_handler) print(target_usage) report = device.find_output_reports() print(report) print(report[0]) buffer = [0x31]*11 buffer[0] = 0 # data to be transmitted from HID to UART buffer[1] = 9 # data length; Range->1 to 9 buffer[2] = 0x36 # data 1 buffer[3] = 0x33 # data 2 buffer[4] = 0x34 # data 3 buffer[5] = 0x35 # data 4
while True: for i in range(8): report[mbed_usage][i] = random.randint(0, 255) report.send() sleep(0.2) except: print 'close' HIDdevice.close() if __name__ == '__main__': # The vendor ID used in the Mbed program mbed_vendor_id = 0x1234 # Vendor page and usage_id = 2 mbed_usage = hid.get_full_usage_id(0xffab, 0x02) # Search the Mbed, attach rx handler and send data findHIDDevice(mbed_usage, mbed_vendor_id) exit() # any hid device filter = hid.HidDeviceFilter() # poll now all_devices = filter.get_devices() if all_devices: print "Found %d matching hid devices" % len(all_devices)
sys.stdout = codecs.getwriter('mbcs')(sys.stdout) vendor_num = 0x03eb product_num = filter = hid.HidDeviceFilter(vendor_i0x2fffd = vendor_num, product_id = product_num) # usb 확인 devices = filter.get_devices() device = devices[0] device.open() print device print "="*10 target_vendor_id = vendor_num target_usage = hid.get_full_usage_id(0xffff, 0x00) print "target_usage=",target_usage # 읽기 핸들러 연결 device.set_raw_data_handler(read_handler) # 쓰기 포트 찾기 report = device.find_output_reports() report = report[0] buffer = [0xFF] * 65 buffer[0] = 0x00 # report ID buffer[1] = 35
for report in device.find_output_reports(): if target_usage in report: print 'target_usage:%x' % target_usage # found out target! #report[target_usage] = 1 # yes, changing values is that easy # at this point you could change different usages at a time... # and finally send the prepared output report #report.send() # now toggle back the signal report[target_usage][0] = 0x1 report[target_usage][1] = 0x4 report[target_usage][2] = 0x4 report[target_usage][3] = 0x4 report[target_usage][4] = 0x4 report.send() print "\nUsage clicked!\n" return finally: device.close() print "The target device was found, but the requested usage does not exist!\n" # if __name__ == '__main__': target_vendor_id = 0x1294 # just an example, change it to the actual vendor_id #target_usage = hid.get_full_usage_id(0xffa0, 0x2) # generic vendor page, usage_id = 2 target_usage = hid.get_full_usage_id( 0xff00, 0x1) # generic vendor page, usage_id = 2 # go for it! click_signal(target_usage, target_vendor_id)
print("Can't find target device (vendor_id = 0x%04x)!" % target_vendor_id) else: # search for our target usage # target pageId, usageId for device in all_devices: try: device.open() # browse output reports, we could search over feature reports also, # changing find_output_reports() to find_feature_reports() for report in device.find_output_reports(): if target_usage in report: # found out target! report[target_usage] = 1 # yes, changing values is that easy # at this point you could change different usages at a time... # and finally send the prepared output report report.send() # now toggle back the signal report[target_usage] = 0 report.send() print("\nUsage clicked!\n") return finally: device.close() print("The target device was found, but the requested usage does not exist!\n") # if __name__ == '__main__': target_vendor_id = 0x16c0 # just an example, change it to the actual vendor_id target_usage = hid.get_full_usage_id(0xFFAB, 0x0270) # generic vendor page, usage_id = 2 # go for it! click_signal(target_usage, target_vendor_id)
if not all_devices: print "Can't find any non system HID device connected" else: # search for our target usage usage_found = False for device in all_devices: try: device.open() # browse feature reports for report in device.find_feature_reports(): if target_usage in report: # we found our usage report.get() # print result print "The value:", list(report[target_usage]) print "All the report:", report.get_raw_data() usage_found = True finally: device.close() if not usage_found: print "The target device was found, but the requested usage does not exist!\n" # if __name__ == '__main__': target_usage = hid.get_full_usage_id( 0x1d34, 0x0004) # generic vendor page, usage_id = 2 # go for it! read_values(target_usage)
# browse output reports for report in HIDdevice.find_output_reports(): if mbed_usage in report: #MBED found print 'Mbed detected' #Attach a custom handler when a data is received HIDdevice.set_raw_data_handler(rx_handler) #send a report each 0.2 second. The report is a random array of 8 bytes while True: for i in range(8): report[mbed_usage][i] = random.randint(0, 255) report.send() sleep(0.2) except: print 'close' HIDdevice.close() if __name__ == '__main__': # The vendor ID used in the Mbed program mbed_vendor_id = 0x1234 # Vendor page and usage_id = 2 mbed_usage = hid.get_full_usage_id(0xffab, 0x02) # Search the Mbed, attach rx handler and send data findHIDDevice(mbed_usage, mbed_vendor_id)
import pywinusb.hid as hid from time import sleep target_vendor_id = 0x0483 target_usage = hid.get_full_usage_id(0x1, 0x3a) # page, usage all_devices = hid.HidDeviceFilter(vendor_id = target_vendor_id).get_devices() if all_devices is None: print("vender ID not found") exit() def sample_handler(data): print("Decimal: {0}".format(data)) print("HEX:", [hex(x) for x in data]) # print("ASCII:", "".join([chr(x) for x in data])) print('------') for device in all_devices: device.open() for report in device.find_output_reports(): print(report) if target_usage in report: device.set_raw_data_handler(sample_handler) buffff = [0] * 64 buffff[0] = 5 buffff[1] = 0 buffff[2] = 3 report.set_raw_data(buffff) report.send()
def test_telephony_hook(): """Browse for non system HID class devices, if a telephony page hook usage control is available monitor value change events""" # play with this value (or set it if you know your device capabilities) # this allows to poll the telephony device for the current usage value input_interrupt_transfers = False # get all currently connected HID devices we could filter by doing # something like hid.HidDeviceFilter(vendor_id = 0x1234), product Id # filters (with masks) and other capabilities also available all_devices = hid.HidDeviceFilter(vendor_id = 0x47f).get_devices() if not all_devices: print("No HID class devices attached.") else: # search for our target usage (the hook button) #target pageId, usageId usage_telephony_hook = hid.get_full_usage_id(0xb, 0x20) def hook_pressed(new_value, event_type): "simple usage control handler" # this simple handler is called on 'pressed' events # this means the usage value has changed from '1' to '0' # no need to check the value event_type = event_type #avoid pylint warnings if new_value: print("On Hook!") else: print("Off Hook!") for device in all_devices: try: device.open() # browse input reports all_input_reports = device.find_input_reports() for input_report in all_input_reports: if usage_telephony_hook in input_report: #found a telephony device w/ hook button print("\nMonitoring {0.vendor_name} {0.product_name} "\ "device.\n".format(device)) print("Press any key to exit monitoring " \ "(or remove HID device)...") # add event handler (example of other available # events: EVT_PRESSED, EVT_RELEASED, EVT_ALL, ...) device.add_event_handler(usage_telephony_hook, hook_pressed, hid.HID_EVT_CHANGED) #level usage if input_interrupt_transfers: # poll the current value (GET_REPORT directive), # allow handler to process result input_report.get() while not kbhit() and device.is_plugged(): #just keep the device opened to receive events sleep(0.5) return finally: device.close() print("Sorry, no one of the attached HID class devices "\ "provide any Telephony Hook button")
filter = hid.HidDeviceFilter(vendor_id=0x16c0, product_id=0x0486) hid_device = filter.get_devices() print("hid_device:") print(hid_device) device = hid_device[0] print("device:") print(device) device.open() out_report = device.find_output_reports() print("out_report") print(out_report) target_usage = hid.get_full_usage_id(0x00, 0x3f) device.set_raw_data_handler(sample_handler) print("target_usage:") print(target_usage) #device.close() data = [0xFF] * 64 for i in range(256): #device.open() #out_report = device.find_output_reports() #print(i) #try: data[0] = i buf = [0] + data out_report[0].set_raw_data(buf)
#print("All the report: {0}".format(report.get_raw_data())) buffer = [0x00]*7 buffer[0] = 0x05 buffer[1] = 0x05 buffer[3] = 0x04 #print("\nSending read data command", buffer) report.set_raw_data(buffer) report.send() #set custom raw data handler device.set_raw_data_handler(readData) print("\nCONNECTED: Waiting for data ... Press any (system keyboard) key to stop...") while not kbhit() and device.is_plugged(): #just keep the device opened to receive events sleep(0.5) return finally: device.close() # if __name__ == '__main__': # 0x2914 used when sync is connected to USB, 0x00F3 when connected over bluetooth target_vendor_id = 0x00F3 target_usage = hid.get_full_usage_id(0xff00, 0x00) # generic vendor page, usage_id = 2 # go for it! click_signal(target_usage, target_vendor_id)
def main(): global keyglove, hidobj # create option parser p = optparse.OptionParser(description='Keyglove API Raw HID Communication Demo for Teensy/Windows (' + __version__ + ')') # set defaults for options p.set_defaults(debug=False) # create serial port options argument group group = optparse.OptionGroup(p, "Connection Options") group.add_option('--debug', '-d', action="store_true", help="Debug mode (show raw RX/TX API packets)") p.add_option_group(group) # actually parse all of the arguments options, arguments = p.parse_args() # create and setup KGLib object keyglove = kglib.KGLib() keyglove.debug = options.debug # add handler for KGAPI timeout condition (hopefully won't happen) keyglove.on_timeout += my_timeout # add handlers for BGAPI events keyglove.kg_evt_protocol_error += my_kg_evt_protocol_error keyglove.kg_rsp_system_ping += my_kg_rsp_system_ping keyglove.kg_rsp_system_reset += my_kg_rsp_system_reset keyglove.kg_evt_system_boot += my_kg_evt_system_boot keyglove.kg_evt_system_ready += my_kg_evt_system_ready keyglove.kg_evt_system_error += my_kg_evt_system_error keyglove.kg_rsp_touch_get_mode += my_kg_rsp_touch_get_mode keyglove.kg_rsp_touch_set_mode += my_kg_rsp_touch_set_mode keyglove.kg_evt_touch_mode += my_kg_evt_touch_mode keyglove.kg_evt_touch_status += my_kg_evt_touch_status keyglove.kg_rsp_feedback_get_blink_mode += my_kg_rsp_feedback_get_blink_mode keyglove.kg_rsp_feedback_set_blink_mode += my_kg_rsp_feedback_set_blink_mode keyglove.kg_rsp_feedback_get_piezo_mode += my_kg_rsp_feedback_get_piezo_mode keyglove.kg_rsp_feedback_set_piezo_mode += my_kg_rsp_feedback_set_piezo_mode keyglove.kg_rsp_feedback_get_vibe_mode += my_kg_rsp_feedback_get_vibe_mode keyglove.kg_rsp_feedback_set_vibe_mode += my_kg_rsp_feedback_set_vibe_mode keyglove.kg_rsp_feedback_get_rgb_mode += my_kg_rsp_feedback_get_rgb_mode keyglove.kg_rsp_feedback_set_rgb_mode += my_kg_rsp_feedback_set_rgb_mode keyglove.kg_evt_feedback_blink_mode += my_kg_evt_feedback_blink_mode keyglove.kg_evt_feedback_piezo_mode += my_kg_evt_feedback_piezo_mode keyglove.kg_evt_feedback_vibe_mode += my_kg_evt_feedback_vibe_mode keyglove.kg_evt_feedback_rgb_mode += my_kg_evt_feedback_rgb_mode keyglove.kg_rsp_motion_get_mode += my_kg_rsp_motion_get_mode keyglove.kg_rsp_motion_set_mode += my_kg_rsp_motion_set_mode keyglove.kg_evt_motion_mode += my_kg_evt_motion_mode keyglove.kg_evt_motion_data += my_kg_evt_motion_data # create hid object (Teensy in Raw HID mode is 16C0:0486) all_hidobjs = hid.HidDeviceFilter(vendor_id=0x16C0, product_id=0x0486).get_devices() if all_hidobjs: print("Listing HID entries matching 16C0:0486...\n") use_id = -1 for index, device in enumerate(all_hidobjs): device_name = unicode("{0.vendor_name}, {0.product_name}" \ " (vID=0x{1:04x}, pID=0x{2:04x})" \ "".format(device, device.vendor_id, device.product_id)) print("{0} => {1}".format(index, device_name)) if device.product_name == "Teensyduino RawHID": use_id = index print "^^^ using this device" break if use_id >= 0: hidobj = all_hidobjs[use_id] try: # open HID device hidobj.open(); hidobj.set_raw_data_handler(keyglove_rawhid_handler) # find correct output report entry to use for sending data target_usage = hid.get_full_usage_id(0xffab, 0x02) output_report = None for report in hidobj.find_output_reports(): if target_usage in report: output_report = report # reboot Keyglove print "Resetting Keyglove..." response = keyglove.send_and_return(output_report, keyglove.kg_cmd_system_reset(), 1) print "Done!" # loop forever until Ctrl+C or device is unplugged while device.is_plugged(): time.sleep(0.01) finally: hidobj.close(); else: print("Keyglove raw HID interface not available!") else: print("There are no HID-class devices available!")