Change serial timeout per read

[James T. Dennis]

rowan at sylvester-bradley.org wrote:
> I'm writing a driver in Python for an old fashioned piece of serial
> equipment. Currently I'm using the USPP serial module. From what I can
> see all the serial modules seem to set the timeout when you open a
> serial port. This is not what I want to do. I need to change the
> timeout each time  I do a "read" on the serial port, depending on
> which part of the protocol I've got to. Sometimes a return character
> is expected within half a second, sometimes within 2 seconds, and
> sometimes within 20 seconds. How do I do this in USPP, or Pyserial, or
> anything else? Currently I'm working in Windows, but I'd prefer a
> platform independent solution if possible...

> Thanks - Rowan

 I'm not familiar with the USPP serial module.  However, I used
 the PySerial package successfully for several months on one job
 to write a full regression testing framework and suite for testing
 a series of different VOIP/SIP phone models (little embedded Linux
 systems) via their diagnostics/JTAG serial headers.

 It had timeout and writeTimeout settings which I recall were fully 
 configurable to fractions of a second, None, and 0 (non-blocking).

 Under Debian it's available as a simple:

	 apt-get -f install python-serial.

 ... and I seem to recall that it worked fine under MS Windows, too.
 (In fact it was written in pure Python, no C-lib or .so/.DLL under it).

 Ahh ... here's the URL:

	http://pyserial.sourceforge.net/

 ... with backends for CPython (Windows and Linux/UNIX/Posix), and Jython.

 Under Python just use:

	>>> import serial 

 ... then use something like:

	>>> s0 = serial.Serial(0)  # Open first serial port: default settings

 ... or:

	>>> s0 = serial.Serial('/dev/ttyS0', 38400, timeout=None) \
		# port by device node/name, setting speed and no timeout
	>>> s1 = serial.Serial(3, 19200, timeout=0) \
		# another by number, non-blocking

 Then use:

	>>> s0.read()  # or s0.readline() for '\n' terminated

 ... and various other methods on these ports.

 BTW: you can change the timeouts on these connection objects
 simply by using s0.timeout=X ... and you can set them to floating
 point values --- so you can use tenths of a second.

 I remember I was also able to adapt my framework classes to add
 support for telnetlib in about an hour of spare time one evening; so
 we could use the serial port to manage testing on one block of phones
 and we could enable the optional telnet port access built-into a
 bank of the other phones and use almost all the same test code with
 them.  (The only difference was that we couldn't capture reboot
 output over the telnet interface; while I could capture and log it
 via the serial ports --- in other words it was a natural limitation of
 the hardware --- and their embedded system didn't enable something like
 a dmesg to capture that after the fact).

 The reason I mention the telnetlib angle serves some purpose other than
 mere rambling and bragging ... I seem to recall that the methods
 supported by the two modules were very closely matched ... so my
 adaptation was extremely straightforward.

 I see that USPP (univ. serial port for Python) is available at:

	http://ibarona.googlepages.com/uspp

 ... and it's supposed to have most of the same features (from a
 quick glance at the web page).  However, there's much more info
 available at the PySerial page ... and PySerial seems to be far
 more recently maintained (with 2.2 "slots' support, for example).

 In addition PySerial seems to be linked to a PyParallel package
 that's "under development" (presumably by the same author).
 (I'm guessing that this latter development can't be done in pure
 Python, though).
 
-- 
Jim Dennis,
Starshine: Signed, Sealed, Delivered