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!")
