[Tutor] Using pyusb

Michael Langford mlangford.cs03 at gtalumni.org
Thu Mar 20 00:26:39 CET 2008

I've never heard of the type of cable you're using. Can you send a
link to one to the list?

You're missing most of the USB ideas more than the python ideas.

USB is very very complicated. The USB spec (of which you care about
chapter 9) is nothing like how most people actually use USB. Most
people use a HID device (even for things that have nothing to do with
human interfaces) and communicate that way.

If you're going to go with a raw control then:
First off: Are you sure you're getting  handle to the device? What is
the fault you are seeing?

Secondly: How do you know what endpoints your device has? Are you sure
you have the right addresses for them? You should be able to see this
with a USB snooping utility.

Control is used to use channel 0 on the USB. It only allows 8 bytes of
data and a time and is usually used to switch between modes on a
device in my experience. You may have to do a write here to put the
device in a mode to do something . This is incredibly device specific.

Secondly, why are you using two different endpoints for read and
write? Usually you can use 82 and 02 both. Is this something in the
cable documentation that tells you to do this?

As you have bulk endpoints, you should be using bulk read/write. There
are 4 types of USB endpoints: Control, Isochronous, Interrupt and

Control Transfers are only sent over endpoint 0.
Isochronous Transfers are sent periodically and are used for "real
time" devices such as web cams (in practice, very very few people ever
use this mode)
Interrupts Transfers are next, they have a high priority after the
first two types and are limited to 256 bytes (IIRC)
Bulk Transfers are JUST like interrupt transfers, except, they are
lower priority.

As you apparently are using a bulk endpoint, you need to use bulk
transfers with it. The priorities are only with regards to the USB
system. Just as long as your device is using all the same priority,
don't worry about which one you use.

Your OS should have some tool to allow you to view the USB descriptors
of the device. This will at least tell you where the endpoints are
that you maybe could be communicating over.

Please check your control panel or the command line utils (or /proc
device) that tells you this info, as well as where you're stuck before
we can help you more.


PS: I would have loved to have know about these modules a couple
months ago. I could have avoided some C kernel modules perhaps.

On Wed, Mar 19, 2008 at 4:14 PM, Mike Holloway <me at mikeholloway.co.uk> wrote:
> Hi all,
>  I'm very new to this list, so hello all!
>  I'm just starting out using python, my background is lamp.
>  t
>  I have a Prolific Technologies bridged usb cable that I wish to talk to
>  using pyusb and libusb, I've tried following examples and compiling my
>  own code but I'm really struggling getting it to work.
>  I'm trying to send a sequence of letters to the cable, for them to
>  reappear on the other side. I've been trying to use bulkWrite and
>  bulkRead methods but I'm not sure I'm using them right. There's also
>  controlMethod, but I'm not sure what that is used for.
>  Can anyone help get me started, I'm concerned mostly with the
>  communication, I reckon I could actually get somewhere if I can just
>  nail the first bit, here's my code so far:
>  * Cheers in advance, Mike.
>  import usb
>  import sys
>  import os
>  import time
>  from array import array
>  class DeviceDescriptor:
>     def __init__(self, vendor_id, product_id, interface_id) :
>         self.vendor_id = vendor_id
>         self.product_id = product_id
>         self.interface_id = interface_id
>     def get_device(self) :
>         buses = usb.busses()
>         for bus in buses :
>             for device in bus.devices :
>                 if device.idVendor == self.vendor_id :
>                     if device.idProduct == self.product_id :
>                         return device
>         return None
>  class XFPS():
>     VENDOR_ID      = 0x067B #: Vendor Id
>     PRODUCT_ID   = 0x0000   #: Product Id for the bridged usb cable
>     INTERFACE_ID = 0        #: The interface we use to talk to the device
>     BULK_IN_EP   = 0x83     #: Endpoint for Bulk reads
>     BULK_OUT_EP  = 0x02     #: Endpoint for Bulk writes
>     PACKET_LENGTH = 0x40    #: 64 bytes
>     device_descriptor = DeviceDescriptor(VENDOR_ID, \
>                                          PRODUCT_ID, INTERFACE_ID)
>     def __init__(self,) :
>         # The actual device (PyUSB object)
>         self.device = self.device_descriptor.get_device()
>         # Handle that is used to communicate with device. Setup in L{open}
>         self.handle = None
>     def open(self) :
>         self.device = self.device_descriptor.get_device()
>         if not self.device:
>             print >> sys.stderr, "Cable isn't plugged in"
>         try:
>             self.handle = self.device.open()
>             self.handle.claimInterface(self.device_descriptor.interface_id)
>         except usb.USBError, err:
>             print >> sys.stderr, err
>     def close(self):
>         """ Release device interface """
>         try:
>             self.handle.reset()
>             self.handle.releaseInterface()
>         except Exception, err:
>             print >> sys.stderr, err
>         self.handle, self.device = None, None
>     def my_bulk_write(self):
>         A = chr(0x75) # u
>         B = chr(0x69) # i
>         X = chr(0x6F) # o
>         Y = chr(0x70) # p
>         LB = chr(0x6C) # l
>         RB = chr(0x6B) # k
>         LT = chr(0x68) # h
>         RT = chr(0x6A) # j
>         S = chr(0x32)
>         s = chr(0x73)
>         self.close()
>         self.open()
>         msg = [A,B,A,B,A,B,A,B]
>         #help(self.handle.bulkWrite)
>         help(self.handle.interruptWrite)
>         sent_bytes = self.handle.interruptWrite(XFPS.BULK_OUT_EP,msg,1000)
>         print sent_bytes
>         if sent_bytes:
>             read_bytes = self.handle.interruptRead(0x81,sent_bytes);
>             print read_bytes
>  xfps = XFPS()
>  xfps.open()
>  xfps.my_bulk_write()
>  _______________________________________________
>  Tutor maillist  -  Tutor at python.org
>  http://mail.python.org/mailman/listinfo/tutor

Michael Langford
Phone: 404-386-0495
Consulting: http://www.RowdyLabs.com

More information about the Tutor mailing list