Question

I am dealing with an Industrial Environment where I must record readings from a serial device out in the field. My current setup involves the device connected to a Moxa 5150A or 5130 Serial Device Server which connects to my network thru wired or wireless means depending on the location of the individual device. At current I am reliant upon software from my hardware vendor to manage the data collection. The current software is windows X86 based and has cause no end of trouble on newer hardware we have purchased due to the failure of previous hardware. I selected the Moxa serial servers specifically for their linux drivers and compatibility. The device communicates over RS-422 (4-wire Half Duplex) 7-bit 1-stop odd-parity and NO-flow control and does not send any information unless requested.

I am working to develop my own solution that will store the information in a database (probably MySQL). In terms of terminal communication this is two part. I must send a request and receive the response.

To date I have installed the Moxa drivers for the serial servers onto my linux server. I have written a bash script that reads from the /dev/ttyrXX device, interprets the input and loads the information into a mysql database.

      while read line
      do
      something something....
      done < /dev/ttyrXX

I am still working out minor scripting bugs such as restarting properly when a device goes offline and later comes back online and other such issues, but my script is reading and logging my data well within my needs.

This solution relies on two factors.

1) the Moxa Devices support FIFO and allow multiple connections simultaneously

2) the vendor provided software running on a separate windows machine is currently submitting requests for information.

I need to remove the windows based software all together. I have written and tested a script that prints to /dev/ttyrXX making my desired requests and received the appropriate responses and had them logged as desired by my first script.

     some list of things
     for x in list
     do         
     printf "request" > /dev/ttyrXX
     done

One of the major issues I have experienced with the vendor supplied software is its hard coded dependence on receiving a timely response to every single request. This creates a number of issues including completely freezing up windows and crashing should the device fall out of service at an inopportune time.

My two scripts working in unison collect the data at a significantly better interval and with alot less human intervention.

Here is my question. What method can I use in Python to obtain comparable results to my Bash script?

I have been unable to locate a Python equivalent to printf or cat that does not require me to open/close a file. Furthermore every terminal interface I’ve looked at has the built-in or required wait for response or read for so long before giving up. I’m certain that something exists out there I have simply had little to no luck finding it. I’ll admit that I am brand spanking new to Python and have not written more than a few lines of code to poke around at its abilities.

Let me be very clear. I want to write to my terminal without concern for anything else when I’m writing (using a thread or separate script I don’t care). I want to read from my terminal without a care in the world for when my next bit of text is coming. (I’m not suggesting a never ending loop, but I do need it to simply stand by and wait for input). I WANT/NEED my write to and read from to be completely independent of one another with no concern for what the other is doing yesterday, right now, or next week.

Thank You in advance.

I will be able to provide more detailed code if that is necessary, However I feel that I am in more need of direction in my searching than for bug fixing. Though I am still completely open to advice and “Don’t EVER DO THIS…. BECAUSE OF THIS…” type input

Answer 1

To expand on what Ignacio is saying. It sounds like the simplest possible solution would be to have two scripts which are started on boot.

One of them opens opens the tty device and listens to it forever. This is a blocking read. It continues to look for new lines of input until it receives (or reaches) an EOF. Presumably this will never happen in this case. It would look something like this:

# tty reader

def listen_to_device():
    with open('/dev/ttyXX', 'r') as tty:
        for line in tty:
            create_db_record(line)

if __name__ == '__main__':
    listen_to_device()

The only thing you would need to implement for that to be a complete working bit of code is the ‘create_db_record’ function.

The second script could be very similar. But maybe it would keep on looking for a particular file in a directory, that contains commands. When it finds any it sends them to the tty device one after the other.

# tty controller

import os
import shutil
import time

def wait_for_commands():
    while True:
        if os.path.exists('/tmp/commands.txt'):
            with open('/tmp/commands.txt', 'r') as c:
                for command in c:
                    send_command(command)
            shutil.move('/tmp/commands.txt', 'tmp/proccesed-' str(datetime.utcnow()))
        time.sleep(1)


def send_command(command):
    with open('/dev/ttyXX', 'w') as tty:
        # maybe do some additional changes to command here?
        tty.write(command)


if __name__ == '__main__':
    wait_for_command()

You could add some additional handling code into the send_command function so that your instructions inside the commands.txt file become very simple.