Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > Python > How to make statements running in strictly sequential fashion like inan interactive shell

Reply
Thread Tools

How to make statements running in strictly sequential fashion like inan interactive shell

 
 
lzlu123
Guest
Posts: n/a
 
      08-19-2011
I have an instrument that has a RS232 type serial comm port and I need
to connect to and control. I use Python 3.2 in Windows XP, plus
pySerial module. I have a problem when I execute a script consisting
of statements that open the comm port, configure it, write strings to
and receive strings from it. Thoese strings aer either commands
pertinent to the instrument (control) or responses from the instrument
(response).

When those statements are executed in a python interpreter
interactively (at >>>), I get what I expect and the results are good
and correct. However, when I execute the script, either being invoked
within the interpreter or run file, I donít get what I want. The
statements in the script is the same as what I use in the interactive
interpreter.

Why do I get the strange behavior and how can I change the script to
make it to behave like in interactive interpreter?

----------------------script-----------------------
def read(comport):

wrt_str=b'movt 3000'+b'\r\n'
ret_str=comport.write(wrt_str)

wrt_str=b'scan'+b'\r\n'
ret_str=comport.write(wrt_str)

rsp_str=comport.readlines() #########1

wrt_str=b'hllo'+b'\r\n'
ret_str=comport.write(wrt_str)

rsp_str=comport.readlines()#########2
----------------------------------------------------------

The problem is with the lines above with #######. In interactive mode,
there is about 1 second delay at #1, and 9 seonds delay at #2. I get
correct responses there. However, if I execute the script above, there
is no delay at all and I get incorrect results (garbage). I set the
read timeout to 0 in comm port set up, as

comport.timeout=0
So the comport should be in blocking mode if it waits for the end of
line or end of file.

I tried many things, like exec (execfile in 2.7), but at no avail.

I have an update to the original post I made a few days ago. I think I
know what the problem is and want to know if anyone has a solution:

After putting "print" and "time.sleep(delay)" after every statement, I
found when the script is running, it appears going around the pyserial
statement, such as "comport.write(..)" or "comport.readlines(...)"
while the pyserial command is executing (appearing as waiting and
busying doing some thing, you know serial port is slow). So for
example, when I exec all statements in a python interactive shell, I
am not able to type and run a new statement if the previous one is not
returned. Let's ay, if comport.readlines() is not returning, I can't
type and run the next comport.write(...) statemtn. However, in a
script that is running, if the comport.readlines() is busy reading,
the next statement is running, if the next statement happens to be a
comport.write() which will abort the reading.

Is there any way to force the python script to behave like running
exactly sequentially?
 
Reply With Quote
 
 
 
 
aspineux
Guest
Posts: n/a
 
      08-19-2011
On Aug 19, 5:00*pm, lzlu123 <(E-Mail Removed)> wrote:
> I have an instrument that has a RS232 type serial comm port and I need
> to connect to and control. I use Python 3.2 in Windows XP, plus
> pySerial module. I have a problem when I execute a script consisting
> of statements that open the comm port, configure it, write strings to
> and receive strings from it. Thoese strings aer either commands
> pertinent to the instrument (control) or responses from the instrument
> (response).
>
> When those statements are executed in a python interpreter
> interactively (at >>>), I get what I expect and the results are good
> and correct. However, when I execute the script, either being invoked
> within the interpreter or run file, I donít get what I want. The
> statements in the script is the same as what I use in the interactive
> interpreter.
>
> Why do I get the strange behavior and how can I change the script to
> make it to behave like in interactive interpreter?
>
> ----------------------script-----------------------
> def read(comport):
>
> * * wrt_str=b'movt 3000'+b'\r\n'
> * * ret_str=comport.write(wrt_str)
>
> * * wrt_str=b'scan'+b'\r\n'
> * * ret_str=comport.write(wrt_str)
>
> * * rsp_str=comport.readlines() #########1



You use readlines() with a s at the end !

* Note that when the serial port was opened with no timeout, that
readline()
* blocks until it sees a newline (or the specified size is reached)
* and that readlines() would never return and therefore refuses to
work
* (it raises an exception in this case)!

>
> * * wrt_str=b'hllo'+b'\r\n'
> * * ret_str=comport.write(wrt_str)
>
> * * rsp_str=comport.readlines()#########2
> ----------------------------------------------------------
>
> The problem is with the lines above with #######. In interactive mode,
> there is about 1 second delay at #1, and 9 seonds delay at #2. I get
> correct responses there. However, if I execute the script above, there
> is no delay at all and I get incorrect results (garbage). I set the
> read timeout to 0 in comm port set up, as
>
> comport.timeout=0
> So the comport should be in blocking mode if it waits for the end of
> line or end of file.


Wrong :

timeout = None: wait forever
timeout = 0: non-blocking mode (return immediately on read)
timeout = x: set timeout to x seconds (float allowed)

>
> I tried many things, like exec (execfile in 2.7), but at no avail.
>
> I have an update to the original post I made a few days ago. I think I
> know what the problem is and want to know if anyone has a solution:
>
> After putting "print" and "time.sleep(delay)" after every statement, I
> found when the script is running, it appears going around the pyserial
> statement, such as "comport.write(..)" or "comport.readlines(...)"
> while the pyserial command is executing (appearing as waiting and
> busying doing some thing, you know serial port is slow). So for
> example, when I exec all statements in a python interactive shell, I
> am not able to type and run a new statement if the previous one is not
> returned. Let's ay, if comport.readlines() is not returning, I can't
> type and run the next comport.write(...) statemtn. However, in a
> script that is running, if the comport.readlines() is busy reading,
> the next statement is running, if the next statement happens to be a
> comport.write() which will abort the reading.
>
> Is there any way to force the python script to behave like running
> exactly sequentially?



You have some new things to try

 
Reply With Quote
 
 
 
 
Javier
Guest
Posts: n/a
 
      08-20-2011
Never used it, but I think you can try this:

Pexpect - a Pure Python Expect-like module
Pexpect is a pure Python Expect-like module. Pexpect makes Python...
www.noah.org/python/pexpect/




lzlu123 <(E-Mail Removed)> wrote:
> I have an instrument that has a RS232 type serial comm port and I need
> to connect to and control. I use Python 3.2 in Windows XP, plus
> pySerial module. I have a problem when I execute a script consisting
> of statements that open the comm port, configure it, write strings to
> and receive strings from it. Thoese strings aer either commands
> pertinent to the instrument (control) or responses from the instrument
> (response).
>
> When those statements are executed in a python interpreter
> interactively (at >>>), I get what I expect and the results are good
> and correct. However, when I execute the script, either being invoked
> within the interpreter or run file, I don???t get what I want. The
> statements in the script is the same as what I use in the interactive
> interpreter.
>
> Why do I get the strange behavior and how can I change the script to
> make it to behave like in interactive interpreter?
>
> ----------------------script-----------------------
> def read(comport):
>
> wrt_str=b'movt 3000'+b'\r\n'
> ret_str=comport.write(wrt_str)
>
> wrt_str=b'scan'+b'\r\n'
> ret_str=comport.write(wrt_str)
>
> rsp_str=comport.readlines() #########1
>
> wrt_str=b'hllo'+b'\r\n'
> ret_str=comport.write(wrt_str)
>
> rsp_str=comport.readlines()#########2
> ----------------------------------------------------------
>
> The problem is with the lines above with #######. In interactive mode,
> there is about 1 second delay at #1, and 9 seonds delay at #2. I get
> correct responses there. However, if I execute the script above, there
> is no delay at all and I get incorrect results (garbage). I set the
> read timeout to 0 in comm port set up, as
>
> comport.timeout=0
> So the comport should be in blocking mode if it waits for the end of
> line or end of file.
>
> I tried many things, like exec (execfile in 2.7), but at no avail.
>
> I have an update to the original post I made a few days ago. I think I
> know what the problem is and want to know if anyone has a solution:
>
> After putting "print" and "time.sleep(delay)" after every statement, I
> found when the script is running, it appears going around the pyserial
> statement, such as "comport.write(..)" or "comport.readlines(...)"
> while the pyserial command is executing (appearing as waiting and
> busying doing some thing, you know serial port is slow). So for
> example, when I exec all statements in a python interactive shell, I
> am not able to type and run a new statement if the previous one is not
> returned. Let's ay, if comport.readlines() is not returning, I can't
> type and run the next comport.write(...) statemtn. However, in a
> script that is running, if the comport.readlines() is busy reading,
> the next statement is running, if the next statement happens to be a
> comport.write() which will abort the reading.
>
> Is there any way to force the python script to behave like running
> exactly sequentially?

 
Reply With Quote
 
lzlu123
Guest
Posts: n/a
 
      08-22-2011
On Aug 19, 6:38*pm, aspineux <(E-Mail Removed)> wrote:
> On Aug 19, 5:00*pm, lzlu123 <(E-Mail Removed)> wrote:
>
>
>
>
>
>
>
>
>
> > I have an instrument that has a RS232 type serial comm port and I need
> > to connect to and control. I use Python 3.2 in Windows XP, plus
> > pySerial module. I have a problem when I execute a script consisting
> > of statements that open the comm port, configure it, write strings to
> > and receive strings from it. Thoese strings aer either commands
> > pertinent to the instrument (control) or responses from the instrument
> > (response).

>
> > When those statements are executed in a python interpreter
> > interactively (at >>>), I get what I expect and the results are good
> > and correct. However, when I execute the script, either being invoked
> > within the interpreter or run file, I donít get what I want. The
> > statements in the script is the same as what I use in the interactive
> > interpreter.

>
> > Why do I get the strange behavior and how can I change the script to
> > make it to behave like in interactive interpreter?

>
> > ----------------------script-----------------------
> > def read(comport):

>
> > * * wrt_str=b'movt 3000'+b'\r\n'
> > * * ret_str=comport.write(wrt_str)

>
> > * * wrt_str=b'scan'+b'\r\n'
> > * * ret_str=comport.write(wrt_str)

>
> > * * rsp_str=comport.readlines() #########1

>
> You use readlines() with a s at the end !
>
> * Note that when the serial port was opened with no timeout, that
> readline()
> * blocks until it sees a newline (or the specified size is reached)
> * and that readlines() would never return and therefore refuses to
> work
> * (it raises an exception in this case)!
>
>
>
>
>
>
>
>
>
>
>
> > * * wrt_str=b'hllo'+b'\r\n'
> > * * ret_str=comport.write(wrt_str)

>
> > * * rsp_str=comport.readlines()#########2
> > ----------------------------------------------------------

>
> > The problem is with the lines above with #######. In interactive mode,
> > there is about 1 second delay at #1, and 9 seonds delay at #2. I get
> > correct responses there. However, if I execute the script above, there
> > is no delay at all and I get incorrect results (garbage). I set the
> > read timeout to 0 in comm port set up, as

>
> > comport.timeout=0
> > So the comport should be in blocking mode if it waits for the end of
> > line or end of file.

>
> Wrong :
>
> * * timeout = None: wait forever
> * * timeout = 0: non-blocking mode (return immediately on read)
> * * timeout = x: set timeout to x seconds (float allowed)
>
>
>
>
>
>
>
>
>
>
>
> > I tried many things, like exec (execfile in 2.7), but at no avail.

>
> > I have an update to the original post I made a few days ago. I think I
> > know what the problem is and want to know if anyone has a solution:

>
> > After putting "print" and "time.sleep(delay)" after every statement, I
> > found when the script is running, it appears going around the pyserial
> > statement, such as "comport.write(..)" or "comport.readlines(...)"
> > while the pyserial command is executing (appearing as waiting and
> > busying doing some thing, you know serial port is slow). So for
> > example, when I exec all statements in a python interactive shell, I
> > am not able to type and run a new statement if the previous one is not
> > returned. Let's ay, if comport.readlines() is not returning, I can't
> > type and run the next comport.write(...) statemtn. However, in a
> > script that is running, if the comport.readlines() is busy reading,
> > the next statement is running, if the next statement happens to be a
> > comport.write() which will abort the reading.

>
> > Is there any way to force the python script to behave like running
> > exactly sequentially?

>
> You have some new things to try


I tried to set the timeout to different values other than 0, but still
got same result -- ruuning script directly behaves differently from
executing statements in interactive shell. I even tried using read
instead of readline(s).
 
Reply With Quote
 
lzlu123
Guest
Posts: n/a
 
      08-22-2011
On Aug 19, 11:06*pm, Javier <(E-Mail Removed)> wrote:
> Never used it, but I think you can try this:
>
> Pexpect - a Pure Python Expect-like module
> Pexpect is a pure Python Expect-like module. Pexpect makes Python...www.noah.org/python/pexpect/
>
>
>
>
>
>
>
> lzlu123 <(E-Mail Removed)> wrote:
> > I have an instrument that has a RS232 type serial comm port and I need
> > to connect to and control. I use Python 3.2 in Windows XP, plus
> > pySerial module. I have a problem when I execute a script consisting
> > of statements that open the comm port, configure it, write strings to
> > and receive strings from it. Thoese strings aer either commands
> > pertinent to the instrument (control) or responses from the instrument
> > (response).

>
> > When those statements are executed in a python interpreter
> > interactively (at >>>), I get what I expect and the results are good
> > and correct. However, when I execute the script, either being invoked
> > within the interpreter or run file, I don???t get what I want. The
> > statements in the script is the same as what I use in the interactive
> > interpreter.

>
> > Why do I get the strange behavior and how can I change the script to
> > make it to behave like in interactive interpreter?

>
> > ----------------------script-----------------------
> > def read(comport):

>
> > * *wrt_str=b'movt 3000'+b'\r\n'
> > * *ret_str=comport.write(wrt_str)

>
> > * *wrt_str=b'scan'+b'\r\n'
> > * *ret_str=comport.write(wrt_str)

>
> > * *rsp_str=comport.readlines() #########1

>
> > * *wrt_str=b'hllo'+b'\r\n'
> > * *ret_str=comport.write(wrt_str)

>
> > * *rsp_str=comport.readlines()#########2
> > ----------------------------------------------------------

>
> > The problem is with the lines above with #######. In interactive mode,
> > there is about 1 second delay at #1, and 9 seonds delay at #2. I get
> > correct responses there. However, if I execute the script above, there
> > is no delay at all and I get incorrect results (garbage). I set the
> > read timeout to 0 in comm port set up, as

>
> > comport.timeout=0
> > So the comport should be in blocking mode if it waits for the end of
> > line or end of file.

>
> > I tried many things, like exec (execfile in 2.7), but at no avail.

>
> > I have an update to the original post I made a few days ago. I think I
> > know what the problem is and want to know if anyone has a solution:

>
> > After putting "print" and "time.sleep(delay)" after every statement, I
> > found when the script is running, it appears going around the pyserial
> > statement, such as "comport.write(..)" or "comport.readlines(...)"
> > while the pyserial command is executing (appearing as waiting and
> > busying doing some thing, you know serial port is slow). So for
> > example, when I exec all statements in a python interactive shell, I
> > am not able to type and run a new statement if the previous one is not
> > returned. Let's ay, if comport.readlines() is not returning, I can't
> > type and run the next comport.write(...) statemtn. However, in a
> > script that is running, if the comport.readlines() is busy reading,
> > the next statement is running, if the next statement happens to be a
> > comport.write() which will abort the reading.

>
> > Is there any way to force the python script to behave like running
> > exactly sequentially?


I am using Python 3.2 in Windows in which Pexpect appeared
problematic.
 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Re: Restart the interactive python shell like in IDLE Chris Rebert Python 1 09-30-2013 04:45 PM
Re: How include a large array? Edward A. Falk C Programming 1 04-04-2013 08:07 PM
Re: Restart the interactive python shell like in IDLE Terry Reedy Python 0 06-11-2009 07:04 PM
Subprocess module: running an interactive shell Roman Medina-Heigl Hernandez Python 3 03-15-2009 12:10 AM
[ANN] deplate 0.7.1 - A tool for converting documents written inan unobtrusive, wiki-like markup to LaTeX, HTML, "HTML slides", or DocBook Thomas Ruby 0 03-03-2005 06:36 PM



Advertisments