Since it sounds like you're on Linux or other POSIX system---

You're cat command is waiting patiently for input from its standard input, which in this case is the terminal.

If you type Cntrl-D, an End-Of-File condition will be sent to the cat command, and it will finish.

You can run ctl-z to background it and then kill the PID.

$ ctl z (to background it)

$ kill -9 {pid} 'of process that just got backgrounded'

If the file(s) in question contain lots of data, sending the signal can actually get to cat before it finishes. What you really observe is the finite speed of your terminal - cat sends the data to the terminal and it takes some time for the terminal to display all of it.

Remember that it usually has to redraw the whole output window for each line of output (i.e. move the contents of the window one line up and print the next line at the bottom). While there are techniques and algorithms to make this faster than if it was done the straightforward way, it still takes some time.

Thus, if you want to get rid of the output as quickly as possible, hide the terminal window, because then (usually) no actual redrawing takes place. In a graphical environment this can mean either minimizing the window or switching to a different virtual desktop, on the Linux virtual console just switch to another one ((Ctrl +)Alt + Fx).

Also notice that if you ran this over a slow network link (SSH over a GSM connection, for example), you would definitely see much less output before cat is killed by the signal, because the speed of the terminal redrawing wouldn't be the bottleneck any more.

The problem is to know when to stop copying from ttyUSB0.

If the end of data is marked with a recognisable character or byte (say, Z) which is guaranteed to not occur elsewhere in the incoming stream, then the following would elegantly solve your problem:

stty -F /dev/ttyUSB0 eof Z 9600 cs8 && cat -v < /dev/ttyUSB0 > /path/to/file.txt

If there is no such single character, but the occurrence of some sequence (say, END) can be used to detect that enough data has been read, then this:

stty -F /dev/ttyUSB0 9600 cs8 && sed '/END/q' < /dev/ttyUSB0 > /path/to/file.txt

would work, on the condition that the incoming data is line-oriented. That is, there must be at least one newline after "END" or sed will not get to see it. (This is precisely why it is good practice to always end text files with a newline.)

Then of course, there is always the rough way. Assuming that you know the job will never take more than a minute:

stty -F /dev/ttyUSB0 9600 cs8 && cat -v < /dev/ttyUSB0 > /path/to/file.txt &
sleep 60 && kill %%

Type Ctrl+D at the start of a new line. ^D is the "end of file" character when typed from a keyboard.

Note that the ^D character itself is not entered into the file. The file ends just before the point where you type ^D.

You need the tr after you read the plaintext file:

#!/bin/bash
printf "generating random file > plaintext \n"
cat -v < plaintext | tr "a-z" "b-y" > generatedtext

In your question plaintext is redirected to tr not cat. Alternatively, you can run the piped commands in a subshell:

#!/bin/bash
printf "generating random file > plaintext \n"
( cat -v | tr "a-z" "b-y" ) < plaintext  > generatedtext