def get_vendor_code_from_os_string_descriptor(handle): print(" Reading OS String Descriptor") # get its length from the descriptor header length = 4 desc = (c_uint8 * length)() request_type = usb.LIBUSB_ENDPOINT_IN request = 0x06 # GET_DESCRIPTOR (0x06) value = (0x03 << 8) | 0xEE # STRING_DESCRIPTOR (0x03), INDEX (0xEE) index = 0x0000 r = usb.control_transfer(handle, request_type, request, value, index, desc, length, 1000) if r == length: length = desc[0] desc = (c_uint8 * length)() # get the full descriptor r = usb.control_transfer(handle, request_type, request, value, index, desc, length, 1000) if r == length: dump_hex(desc, r) return desc[MS_OS_DESC_VENDOR_CODE_OFFSET] # Another way # Read the OS String Descriptor at string index 0xEE desc = (c_uint8 * MS_OS_DESC_STRING_LENGTH)() r = usb.get_string_descriptor(handle, MS_OS_DESC_STRING_INDEX, 0, desc, MS_OS_DESC_STRING_LENGTH) if r == MS_OS_DESC_STRING_LENGTH and memcmp( ms_os_desc_string, desc, sizeof(ms_os_desc_string)) == 0: dump_hex(desc, r) return desc[MS_OS_DESC_VENDOR_CODE_OFFSET]
def read_ms_os_10_descriptors(handle): print("\nReading MS OS 1.0 Descriptors\n") vendor_code = get_vendor_code_from_os_string_descriptor(handle) if not vendor_code: print(" OS String Descriptor is not found") return print(" Reading Extended Compat ID OS Feature Descriptor") request_type = usb.LIBUSB_ENDPOINT_IN | usb.LIBUSB_REQUEST_TYPE_VENDOR | usb.LIBUSB_RECIPIENT_DEVICE request = vendor_code value = 0x0000 index = 0x0004 length = 8 desc = (c_uint8 * length)() # Read the descriptor header r = usb.control_transfer(handle, request_type, request, value, index, desc, length, 1000) if r != length: print(" Extended Compat ID OS Feature Descriptor is not found") return length = cast(desc, POINTER(c_uint32))[0] # c_uint32 # Read the full feature descriptor desc = (c_uint8 * length)() r = usb.control_transfer(handle, request_type, request, value, index, desc, length, 1000) if r != length: print(" Extended Compat ID OS Feature Descriptor is not found") return dump_hex(desc, r)
def read_ms_os_20_descriptors(handle, vendor_code): print("\nReading MS OS 2.0 descriptors\n") print(" Reading MS OS 2.0 descriptor set header") request_type = usb.LIBUSB_ENDPOINT_IN | usb.LIBUSB_REQUEST_TYPE_VENDOR | usb.LIBUSB_RECIPIENT_DEVICE request = vendor_code value = 0x0000 index = 0x0007 length = 10 desc = (c_uint8 * length)() # Read the descriptor header r = usb.control_transfer(handle, request_type, request, value, index, desc, length, 1000) if r != length: print(" Not found") return dump_hex(desc, r) length = cast(pointer(desc), POINTER(c_uint16))[4] # Read the full feature descriptor desc = (c_uint8 * length)() r = usb.control_transfer(handle, request_type, request, value, index, desc, length, 1000) if r != length: print(" Not found") return dump_hex(desc, r)
def display_xbox_status(handle): # The XBOX Controller is really a HID device that got its HID Report Descriptors # removed by Microsoft. # Input/Output reports described at http://euc.jp/periphs/xbox-controller.ja.html input_report = (20 * ct.c_uint8)() print("\nReading XBox Input Report...") r = usb.control_transfer( handle, usb.LIBUSB_ENDPOINT_IN | usb.LIBUSB_REQUEST_TYPE_CLASS | usb.LIBUSB_RECIPIENT_INTERFACE, HID_GET_REPORT, (HID_REPORT_TYPE_INPUT << 8) | 0x00, 0, input_report, 20, 1000) if r < 0: return err_exit(r) print(" D-pad: {:02X}".format(input_report[2] & 0x0F)) print(" Start:{}, Back:{}, " "Left Stick Press:{}, Right Stick Press:{}".format( B(input_report[2] & 0x10), B(input_report[2] & 0x20), B(input_report[2] & 0x40), B(input_report[2] & 0x80))) # A, B, X, Y, Black, White are pressure sensitive print(" A:{}, B:{}, X:{}, Y:{}, White:{}, Black:{}".format( input_report[4], input_report[5], input_report[6], input_report[7], input_report[9], input_report[8])) print(" Left Trigger: {}, Right Trigger: {}".format( input_report[10], input_report[11])) print(" Left Analog (X,Y): ({},{})".format( int16_t((input_report[13] << 8) | input_report[12]), int16_t((input_report[15] << 8) | input_report[14]))) print(" Right Analog (X,Y): ({},{})".format( int16_t((input_report[17] << 8) | input_report[16]), int16_t((input_report[19] << 8) | input_report[18]))) return 0
def ezusb_cpucs(device, addr, do_run): global verbose data = ct.c_uint8(0x00 if do_run else 0x01) if verbose: logerror("{}\n", "stop CPU" if data else "reset CPU") status = usb.control_transfer(device, usb.LIBUSB_ENDPOINT_OUT | usb.LIBUSB_REQUEST_TYPE_VENDOR | usb.LIBUSB_RECIPIENT_DEVICE, RW_INTERNAL, addr & 0xFFFF, addr >> 16, ct.byref(data), 1, 1000); if (status != 1 and # We may get an I/O error from libusb as the device disappears (not do_run or status != usb.LIBUSB_ERROR_IO)): mesg = "can't modify CPUCS" if status < 0: logerror("{}: {}\n", mesg, usb.error_name(status)) else: logerror("{}\n", mesg) return False else: return True
def _make_control_transfer(self, request_type, b_request, w_value, w_index, data, size, timeout=2000): """ Read/Write data from USB device. :param request_type: Request type value. Combines direction, type and recipient enum values. Bit 7: Request direction (0=Host to device - Out, 1=Device to host - In). Bits 5-6: Request type (0=standard, 1=class, 2=vendor, 3=reserved). Bits 0-4: Recipient (0=device, 1=interface, 2=endpoint,3=other). :param b_request: Request field for the setup packet. The actual request, see USBRequestCodes Enum. :param w_value: Value field for the setup packet. A word-size value that varies according to the request. For example, in the CLEAR_FEATURE request the value is used to select the feature, in the GET_DESCRIPTOR request the value indicates the descriptor type and in the SET_ADDRESS request the value contains the device address. :param w_index: Index field for the setup packet. A word-size value that varies according to the request. The index is generally used to specify an endpoint or an interface. :param data: ctypes structure class. :param size: size of data. :return: True if successful otherwise False. https://www.jungo.com/st/support/documentation/windriver/802/wdusb_man_mhtml/node55.html#SECTION001213000000000000000 """ if self.interface is None: raise USBDeviceInterfaceNotClaimedError(self.dev_key) if not isinstance(b_request, USBRequestCode): raise ValueError( 'b_request argument must be USBRequestCode enum value.') ret = usb.control_transfer( self.__libusb_dev_handle__, # ct.c_char_p request_type, # ct.c_uint8 b_request, # ct.c_uint8, must be a USBRequestCode Enum value. w_value, # ct.c_uint16 w_index, # ct.c_uint16 ct.cast(data, ct.POINTER(ct.c_ubyte)), # ct.POINTER(ct.c_ubyte) ct.c_uint16(size), # ct.c_uint16 timeout) # ct.c_uint32 if ret >= 0: if request_type & USBRequestDirection.ENDPOINT_IN: _logger.debug('Read {} bytes from'.format(size) + f' {self.dev_key}.') else: _logger.debug('Wrote {} bytes to'.format(size) + f' {self.dev_key}.') return True usb_error(ret, _('Failed to communicate with device') + f' {self.dev_key}.') return False
def get_hwstat(status): global devh r = usb.control_transfer(devh, CTRL_IN, USB_RQ, 0x07, 0, ct.byref(status), 1, 0) if r < 0: print("read hwstat error {}".format(r), file=sys.stderr) return r if r < 1: print("short read ({})".format(r), file=sys.stderr) return -1 print("hwstat reads {:02x}".format(status)) return 0
def set_hwstat(status): global devh print("set hwstat to {:02x}".format(status)) r = usb.control_transfer(devh, CTRL_OUT, USB_RQ, 0x07, 0, ct.byref(status), 1, 0) if r < 0: print("set hwstat error {}".format(r), file=sys.stderr) return r if r < 1: print("short write ({})".format(r), file=sys.stderr, end="") return -1 return 0
def set_mode(data): global devh print("set mode {:02x}".format(data)) r = usb.control_transfer(devh, CTRL_OUT, USB_RQ, 0x4e, 0, ct.byref(data), 1, 0) if r < 0: print("set mode error {}".format(r), file=sys.stderr) return r if r < 1: print("short write ({})".format(r), file=sys.stderr, end="") return -1 return 0
def set_xbox_actuators(handle, left, right): print("\nWriting XBox Controller Output Report...") output_report = (6 * ct.c_uint8)() output_report[1] = ct.sizeof(output_report) output_report[3] = left output_report[5] = right r = usb.control_transfer( handle, usb.LIBUSB_ENDPOINT_OUT | usb.LIBUSB_REQUEST_TYPE_CLASS | usb.LIBUSB_RECIPIENT_INTERFACE, HID_SET_REPORT, (HID_REPORT_TYPE_OUTPUT << 8) | 0x00, 0, output_report, 6, 1000) if r < 0: return err_exit(r) return 0
def print_f0_data(): global devh data = (ct.c_ubyte * 0x10)() r = usb.control_transfer(devh, CTRL_IN, USB_RQ, 0xf0, 0, data, ct.sizeof(data), 0) if r < 0: print("F0 error {}".format(r), file=sys.stderr) return r if r < ct.sizeof(data): print("short read ({})".format(r), file=sys.stderr) return -1 print("F0 data:", end="") for i in range(ct.sizeof(data)): print("{:02x} ".format(data[i]), end="") print() return 0
def ezusb_read(device, label, opcode, addr, data, size): global verbose if verbose > 1: logerror("{}, addr {:#010x} len %4u ({:#06x})\n", label, addr, size, size) status = usb.control_transfer( device, usb.LIBUSB_ENDPOINT_IN | usb.LIBUSB_REQUEST_TYPE_VENDOR | usb.LIBUSB_RECIPIENT_DEVICE, opcode, addr & 0xFFFF, addr >> 16, ct.cast(data, ct.POINTER(ct.c_ubyte)), ct.c_uint16(size), 1000) if status != ct.c_int(size).value: if status < 0: logerror("{}: {}\n", label, usb.error_name(status)) else: logerror("{} ==> {}\n", label, status) return 0 if status >= 0 else -errno.EIO
def ezusb_fx3_jump(device, addr): global verbose if verbose: logerror("transfer execution to Program Entry at {:#010x}\n", addr) status = usb.control_transfer( device, usb.LIBUSB_ENDPOINT_OUT | usb.LIBUSB_REQUEST_TYPE_VENDOR | usb.LIBUSB_RECIPIENT_DEVICE, RW_INTERNAL, addr & 0xFFFF, addr >> 16, NULL, 0, 1000) # We may get an I/O error from libusb as the device disappears if status != 0 and status != usb.LIBUSB_ERROR_IO: mesg = "failed to send jump command" if status < 0: logerror("{}: {}\n", mesg, usb.error_name(status)) else: logerror("{}\n", mesg) return False else: return True
def read_ms_winsub_feature_descriptors(handle, bRequest, iface_number): # Read the MS WinUSB Feature Descriptors, that are used on Windows 8 for automated driver installation MAX_OS_FD_LENGTH = 256 #int r; os_desc = (ct.c_uint8 * MAX_OS_FD_LENGTH)() class struct_os_fd(ct.Structure): _fields_ = [ ("desc", ct.c_char_p), ("recipient", ct.c_uint8), ("index", ct.c_uint16), ("header_size", ct.c_uint16), ] os_fd = [ struct_os_fd(b"Extended Compat ID", usb.LIBUSB_RECIPIENT_DEVICE, 0x0004, 0x10), struct_os_fd(b"Extended Properties", usb.LIBUSB_RECIPIENT_INTERFACE, 0x0005, 0x0A), ] if iface_number < 0: return # WinUSB has a limitation that forces wIndex to the interface number when issuing # an Interface Request. To work around that, we can force a Device Request for # the Extended Properties, assuming the device answers both equally. if force_device_request: os_fd[1].recipient = usb.LIBUSB_RECIPIENT_DEVICE for i in range(2): print("\nReading {} OS Feature Descriptor (wIndex = 0x%04d):".format( os_fd[i].desc, os_fd[i].index)) # Read the header part r = usb.control_transfer(handle, ct.c_uint8(usb.LIBUSB_ENDPOINT_IN | usb.LIBUSB_REQUEST_TYPE_VENDOR | os_fd[i].recipient), bRequest, ct.c_uint16((iface_number << 8) | 0x00), os_fd[i].index, os_desc, os_fd[i].header_size, 1000) if r < os_fd[i].header_size: perr(" Failed: {}", usb.strerror(usb.error(r)) if r < 0 else "header size is too small") return le_type_punning_IS_fine = ct.cast(os_desc, ct.c_void_p) length = ct.cast(le_type_punning_IS_fine, ct.POINTER(ct.c_uint32))[0].value # ct.c_uint32 length = min(length, MAX_OS_FD_LENGTH) # Read the full feature descriptor r = usb.control_transfer(handle, ct.c_uint8(usb.LIBUSB_ENDPOINT_IN | usb.LIBUSB_REQUEST_TYPE_VENDOR | os_fd[i].recipient), bRequest, ct.c_uint16((iface_number << 8) | 0x00), os_fd[i].index, os_desc, ct.c_uint16(length), 1000) if r < 0: perr(" Failed: {}", usb.strerror(usb.error(r))) return else: display_buffer_hex(os_desc, r)
def test_hid(handle, endpoint_in): global binary_dump global binary_name #int r; hid_report_descriptor = (ct.c_uint8 * 256)() report_buffer = ct.POINTER(ct.c_uint8) print("\nReading HID Report Descriptors:") descriptor_size = usb.control_transfer(handle, usb.LIBUSB_ENDPOINT_IN | usb.LIBUSB_REQUEST_TYPE_STANDARD | usb.LIBUSB_RECIPIENT_INTERFACE, usb.LIBUSB_REQUEST_GET_DESCRIPTOR, usb.LIBUSB_DT_REPORT << 8, 0, hid_report_descriptor, ct.sizeof(hid_report_descriptor), 1000) if descriptor_size < 0: print(" Failed") return -1 display_buffer_hex(hid_report_descriptor, descriptor_size) if binary_dump: try: fd = open(binary_name, "w") except: pass else: with fd: if fd.fwrite(hid_report_descriptor, descriptor_size) != descriptor_size: print(" Error writing descriptor to file") size = get_hid_record_size(hid_report_descriptor, descriptor_size, HID_REPORT_TYPE_FEATURE) if size <= 0: print("\nSkipping Feature Report readout (None detected)") else: report_buffer = ct.cast(calloc(size, 1), ct.POINTER(ct.c_uint8)) if not report_buffer: return -1 print("\nReading Feature Report (length {})...".format(size)) r = usb.control_transfer(handle, usb.LIBUSB_ENDPOINT_IN | usb.LIBUSB_REQUEST_TYPE_CLASS | usb.LIBUSB_RECIPIENT_INTERFACE, HID_GET_REPORT, (HID_REPORT_TYPE_FEATURE << 8) | 0, 0, report_buffer, ct.c_uint16(size), 5000) if r >= 0: display_buffer_hex(report_buffer, size) else: if r == usb.LIBUSB_ERROR_NOT_FOUND: print(" No Feature Report available for this device") elif r == usb.LIBUSB_ERROR_PIPE: print(" Detected stall - resetting pipe...") usb.clear_halt(handle, 0) else: print(" Error: {}".format(usb.strerror(usb.error(r)))) free(report_buffer) size = get_hid_record_size(hid_report_descriptor, descriptor_size, HID_REPORT_TYPE_INPUT) if size <= 0: print("\nSkipping Input Report readout (None detected)") else: report_buffer = ct.cast(calloc(size, 1), ct.POINTER(ct.c_uint8)) if not report_buffer: return -1 print("\nReading Input Report (length {})...".format(size)) r = usb.control_transfer(handle, usb.LIBUSB_ENDPOINT_IN | usb.LIBUSB_REQUEST_TYPE_CLASS | usb.LIBUSB_RECIPIENT_INTERFACE, HID_GET_REPORT, (HID_REPORT_TYPE_INPUT << 8) | 0x00, 0, report_buffer, ct.c_uint16(size), 5000) if r >= 0: display_buffer_hex(report_buffer, size) else: if r == usb.LIBUSB_ERROR_TIMEOUT: print(" Timeout! Please make sure you act on the device within the 5 seconds allocated...") elif r == usb.LIBUSB_ERROR_PIPE: print(" Detected stall - resetting pipe...") usb.clear_halt(handle, 0) else: print(" Error: {}".format(usb.strerror(usb.error(r)))) # Attempt a bulk read from endpoint 0 (this should just return a raw input report) print("\nTesting interrupt read using endpoint {:02X}...".format(endpoint_in)) r = usb.interrupt_transfer(handle, endpoint_in, report_buffer, size, ct.byref(size), 5000) if r >= 0: display_buffer_hex(report_buffer, size) else: print(" {}".format(usb.strerror(usb.error(r)))) free(report_buffer) return 0
def test_mass_storage(handle, endpoint_in, endpoint_out): # Mass Storage device to test bulk transfers (non destructive test) global binary_dump global binary_name #int r; #ct.c_uint32 i print("Reading Max LUN:") lun = ct.c_uint8() r = usb.control_transfer(handle, usb.LIBUSB_ENDPOINT_IN | usb.LIBUSB_REQUEST_TYPE_CLASS | usb.LIBUSB_RECIPIENT_INTERFACE, BOMS_GET_MAX_LUN, 0, 0, ct.byref(lun), 1, 1000) lun = lun.value # Some devices send a STALL instead of the actual value. # In such cases we should set lun to 0. if r == 0: lun = 0 elif r < 0: perr(" Failed: {}".format(usb.strerror(usb.error(r)))) print(" Max LUN = {}".format(lun)) # Send Inquiry print("Sending Inquiry:") buffer = (ct.c_uint8 * 64)() cdb = (ct.c_uint8 * 16)() # SCSI Command Descriptor Block cdb[0] = 0x12 # Inquiry cdb[4] = INQUIRY_LENGTH expected_tag = ct.c_uint32() send_mass_storage_command(handle, endpoint_out, lun, cdb, usb.LIBUSB_ENDPOINT_IN, INQUIRY_LENGTH, ct.pointer(expected_tag)) size = ct.c_int() r = usb.bulk_transfer(handle, endpoint_in, ct.cast(ct.pointer(buffer), ct.POINTER(ct.c_ubyte)), INQUIRY_LENGTH, ct.byref(size), 1000) if r < 0: return err_exit(r) size = size.value print(" received {} bytes".format(size)) # The following strings are not zero terminated vid = (ct.c_char * 9)() pid = (ct.c_char * 9)() rev = (ct.c_char * 5)() for i in range(8): vid[i] = buffer[8 + i] pid[i] = buffer[16 + i] rev[i / 2] = buffer[32 + i / 2] # instead of another loop vid[8] = 0 pid[8] = 0 rev[4] = 0 print(" VID:PID:REV \"%8s\":\"%8s\":\"%4s\"".format(vid, pid, rev)) if get_mass_storage_status(handle, endpoint_in, expected_tag) == -2: get_sense(handle, endpoint_in, endpoint_out) # Read capacity print("Reading Capacity:") buffer = (ct.c_uint8 * 64)() cdb = (ct.c_uint8 * 16)() # SCSI Command Descriptor Block cdb[0] = 0x25 # Read Capacity expected_tag = ct.c_uint32() send_mass_storage_command(handle, endpoint_out, lun, cdb, usb.LIBUSB_ENDPOINT_IN, READ_CAPACITY_LENGTH, ct.pointer(expected_tag)) size = ct.c_int() r = usb.bulk_transfer(handle, endpoint_in, ct.cast(ct.pointer(buffer), ct.POINTER(ct.c_ubyte)), READ_CAPACITY_LENGTH, ct.byref(size), 1000) if r < 0: return err_exit(r) size = size.value print(" received {} bytes".format(size)) max_lba = be_to_int32(buffer[0:]) block_size = be_to_int32(buffer[4:]) device_size = (max_lba + 1.0) * block_size / (1024 * 1024 * 1024) print(" Max LBA: {:08X}, Block Size: {:08X} (%.2f GB)".format( max_lba, block_size, device_size)) if get_mass_storage_status(handle, endpoint_in, expected_tag) == -2: get_sense(handle, endpoint_in, endpoint_out) # coverity[tainted_data] try: data = ct.cast(calloc(1, block_size), ct.POINTER(ct.c_ubyte)) # unsigned char* except: perr(" unable to allocate data buffer\n") return -1 # Send Read print("Attempting to read %u bytes:".format(block_size)) cdb = (ct.c_uint8 * 16)() # SCSI Command Descriptor Block cdb[0] = 0x28 # Read(10) cdb[8] = 0x01 # 1 block expected_tag = ct.c_uint32() send_mass_storage_command(handle, endpoint_out, lun, cdb, usb.LIBUSB_ENDPOINT_IN, block_size, ct.pointer(expected_tag)) size = ct.c_int() usb.bulk_transfer(handle, endpoint_in, data, block_size, ct.byref(size), 5000) size = size.value print(" READ: received {} bytes".format(size)) if get_mass_storage_status(handle, endpoint_in, expected_tag) == -2: get_sense(handle, endpoint_in, endpoint_out) else: display_buffer_hex(data, size) if binary_dump: try: fd = open(binary_name, "w") except: pass else: with fd: if fd.fwrite(data, ct.c_size_t(size).value) != ct.c_uint(size).value: perr(" unable to write binary data\n") free(data) return 0
def display_ps3_status(handle): # The PS3 Controller is really a HID device that got its HID Report Descriptors # removed by Sony input_report = (ct.c_uint8 * 49)() master_bt_address = (ct.c_uint8 * 8)() device_bt_address = (ct.c_uint8 * 18)() # Get the controller's bluetooth address of its master device r = usb.control_transfer(handle, usb.LIBUSB_ENDPOINT_IN | usb.LIBUSB_REQUEST_TYPE_CLASS | usb.LIBUSB_RECIPIENT_INTERFACE, HID_GET_REPORT, 0x03f5, 0, master_bt_address, ct.sizeof(master_bt_address), 100) if r < 0: return err_exit(r) print("\nMaster's bluetooth address: " "{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}".format( master_bt_address[2], master_bt_address[3], master_bt_address[4], master_bt_address[5], master_bt_address[6], master_bt_address[7])) # Get the controller's bluetooth address r = usb.control_transfer(handle, usb.LIBUSB_ENDPOINT_IN | usb.LIBUSB_REQUEST_TYPE_CLASS | usb.LIBUSB_RECIPIENT_INTERFACE, HID_GET_REPORT, 0x03f2, 0, device_bt_address, ct.sizeof(device_bt_address), 100) if r < 0: return err_exit(r) print("\nMaster's bluetooth address: " "{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}".format( device_bt_address[4], device_bt_address[5], device_bt_address[6], device_bt_address[7], device_bt_address[8], device_bt_address[9])) # Get the status of the controller's buttons via its HID report print("\nReading PS3 Input Report...") r = usb.control_transfer(handle, usb.LIBUSB_ENDPOINT_IN | usb.LIBUSB_REQUEST_TYPE_CLASS | usb.LIBUSB_RECIPIENT_INTERFACE, HID_GET_REPORT, (HID_REPORT_TYPE_INPUT << 8) | 0x01, 0, input_report, ct.sizeof(input_report), 1000) if r < 0: return err_exit(r) pressed = input_report[2] # Direction pad plus start, select, and joystick buttons if pressed == 0x01: print("\tSELECT pressed") elif pressed == 0x02: print("\tLEFT 3 pressed") elif pressed == 0x04: print("\tRIGHT 3 pressed") elif pressed == 0x08: print("\tSTART presed") elif pressed == 0x10: print("\tUP pressed") elif pressed == 0x20: print("\tRIGHT pressed") elif pressed == 0x40: print("\tDOWN pressed") elif pressed == 0x80: print("\tLEFT pressed") pressed = input_report[3] # Shapes plus top right and left buttons if pressed == 0x01: print("\tLEFT 2 pressed") elif pressed == 0x02: print("\tRIGHT 2 pressed") elif pressed == 0x04: print("\tLEFT 1 pressed") elif pressed == 0x08: print("\tRIGHT 1 presed") elif pressed == 0x10: print("\tTRIANGLE pressed") elif pressed == 0x20: print("\tCIRCLE pressed") elif pressed == 0x40: print("\tCROSS pressed") elif pressed == 0x80: print("\tSQUARE pressed") print("\tPS button: {}".format(input_report[4])) print("\tLeft Analog (X,Y): ({},{})".format(input_report[6], input_report[7])) print("\tRight Analog (X,Y): ({},{})".format(input_report[8], input_report[9])) print("\tL2 Value: {}\tR2 Value: {}".format(input_report[18], input_report[19])) print("\tL1 Value: {}\tR1 Value: {}".format(input_report[20], input_report[21])) print("\tRoll (x axis): {} Yaw (y axis): {} Pitch (z axis) {}".format( #(((input_report[42] + 128) % 256) - 128), int8_t(input_report[42]), int8_t(input_report[44]), int8_t(input_report[46]))) print("\tAcceleration: {}".format(int8_t(input_report[48]))) print() return 0