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

Discussion in 'Python' started by lzlu123, Aug 19, 2011.

  1. lzlu123

    lzlu123 Guest

    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?
     
    lzlu123, Aug 19, 2011
    #1
    1. Advertising

  2. lzlu123

    aspineux Guest

    Re: How to make statements running in strictly sequential fashionlike in an interactive shell

    On Aug 19, 5:00 pm, lzlu123 <> 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
     
    aspineux, Aug 19, 2011
    #2
    1. Advertising

  3. lzlu123

    Javier Guest

    Re: How to make statements running in strictly sequential fashion like in an interactive shell

    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 <> 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?
     
    Javier, Aug 20, 2011
    #3
  4. lzlu123

    lzlu123 Guest

    Re: How to make statements running in strictly sequential fashionlike in an interactive shell

    On Aug 19, 6:38 pm, aspineux <> wrote:
    > On Aug 19, 5:00 pm, lzlu123 <> 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).
     
    lzlu123, Aug 22, 2011
    #4
  5. lzlu123

    lzlu123 Guest

    Re: How to make statements running in strictly sequential fashionlike in an interactive shell

    On Aug 19, 11:06 pm, Javier <> 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 <> 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.
     
    lzlu123, Aug 22, 2011
    #5
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. alf
    Replies:
    9
    Views:
    299
    Colin J. Williams
    Mar 17, 2007
  2. Roman Medina-Heigl Hernandez

    Subprocess module: running an interactive shell

    Roman Medina-Heigl Hernandez, Mar 14, 2009, in forum: Python
    Replies:
    3
    Views:
    1,557
    Karthik Gurusamy
    Mar 15, 2009
  3. Chris Rebert
    Replies:
    1
    Views:
    1,140
    Ricardo Abreu
    Sep 30, 2013
  4. Terry Reedy
    Replies:
    0
    Views:
    644
    Terry Reedy
    Jun 11, 2009
  5. Thomas
    Replies:
    0
    Views:
    191
    Thomas
    Mar 3, 2005
Loading...

Share This Page