Bi-directional IOStream seems to mix input and output in unhealthy way

[sgaure]

Hi,

I posted this on discourse and was advised to post a bug report about this.

The problem is, I have an fpga hooked up to the usb on my Ubuntu-box. The ftdi-driver makes it look like a uart, a serial port, /dev/fpga. It works like this, I send it a short string to start it. I read output for a minute, then send a new short string to stop the output, change some parameters, and restart output, and read for another minute. And so on.

So it looks something like this:

io = open("/dev/fpga",  read=true, write=true)
for i in 1:N
  write(io,"p N=$i "); flush(io) # change parameter
  write(io,"r"); flush(io) # resume
  while <less than a minute passed>
     read!(io,buffer)
     process(buffer)  # mainly a push! on an array
  end
  write(io,"s"); flush(io) # stop
  <spawn some post-processing>
end

Now, the problem is that the fpga has quite some speed, and it manages to write several bytes between the final read! and the stop command at the end of the loop. This is not a problem, these bytes will be ignored by the processing routine.

However, when strace’ing reads and writes it transpires that the string “p N=$i ” at the top of the loop has a few bytes prepended in the (system) write(), and it turns out to be bytes which the fpga has written to me and which I have not yet read (and which I will discard in the loop). These are then written back to the fpga. Occasionally, these bytes will be interpreted by the fpga as a command, and havoc ensues. The serial line is in raw-mode (i.e. with cfmakeraw()), verified by stty, no echo and such stuff.

It looks like the read() and write() shares a buffer. Things work fine when I replace open/read/write with ccall to open/read/write, i.e. when I bypass julia IO.

Discourse thread: https://discourse.julialang.org/t/read-write-on-serial-port-mixes-input-and-output/55486

[JeffBezanson]

I think the problem is that our file code assumes files are seekable and have a meaningful current position. As a workaround, try Base.Filesystem.open(filename, Base.Filesystem.JL_O_RDWR) for now.

[JeffBezanson]

Another possibility is to open the file twice, once for reading and once for writing.

[notthetup]

I've noticed this as well..

I'm using Julia to read/write from a terminal device (tty) on a Single Board Computer (SBC). I've noticed when I do Base.write, some of the bytes from the previously done Base.read are written back along with whatever I passed to Base.write.

I've tested this on both Julia 1.6.2 and Julia 1.7.0 on a nVIDIA Jetson running Ubuntu 18.08.

The easiest way to reproduce this is by shorting the UART TX/RX pins on the SBC, so that the terminal loopback-ed. Whatever goes out the TX, comes back into the RX. Then I turned off TERMIOS level echo.

Now when I do Base.write, I should be able to read back the same string. But when I do Base.write the second time, the string I read back is a concatenation of both the strings.

ubuntu@unet:~$ stty -echo -F /dev/ttyTHS2

ubuntu@unet:~$ stty -a -F /dev/ttyTHS2
speed 115200 baud; rows 0; columns 0; line = 0;
intr = ^C; quit = ^\; erase = ^?; kill = ^U; eof = ^D; eol = <undef>; eol2 = <undef>;
swtch = <undef>; start = ^Q; stop = ^S; susp = ^Z; rprnt = ^R; werase = ^W; lnext = ^V;
discard = ^O; min = 100; time = 2;
-parenb -parodd -cmspar cs8 -hupcl -cstopb cread clocal -crtscts
-ignbrk brkint ignpar -parmrk -inpck -istrip -inlcr -igncr -icrnl ixon -ixoff -iuclc
-ixany -imaxbel -iutf8
-opost -olcuc -ocrnl -onlcr -onocr -onlret -ofill -ofdel nl0 cr0 tab0 bs0 vt0 ff0
-isig -icanon iexten -echo echoe echok -echonl -noflsh -xcase -tostop -echoprt echoctl
echoke -flusho -extproc

ubuntu@unet:~$ julia
...

julia> io = open("/dev/ttyTHS2", "r+")
IOStream(<file /dev/ttyTHS2>)

julia> write(io, "hello"); flush(io)

julia> read(io, String)
"hello"

julia> write(io, "world"); flush(io)

julia>read(io, String)
"helloworld"

Also discussed in this issue : https://discourse.julialang.org/t/read-write-on-serial-port-mixes-input-and-output/55486

[notthetup]

@JeffBezanson Base.Filesystem.open(filename, Base.Filesystem.JL_O_RDWR) doesn't help. I get SystemError: lseek: Illegal seek when I do a Base.read on that File.