Thread: Best way to read character input from serial port (Linux)?

I've got an app that reads characters from a serial port, evaluates these characters and then responds if necessary. I have it working somewhat, but it's not totally reliable. The main issue is that I have a while loop that constantly reads input but I can't figure out how to determine when new characters are sent -- it just reads constantly, sets a variable and outputs it. So, if the master device sends two characters, "0x61, 0x20", My output looks like this:

61
20
20
20
20
20
...and so on forever, since the var that holds the input hasn't been reset.

The bigger issue is that depending on the timing of the while loop, old characters may get mixed up with new input from the master device, which throws everything off. I need the loop to STOP outputting until it knows for sure that new characters are being sent.

Example:

Code:

int fd_serialport;
struct termios options;

fd_serialport = open("/dev/ttyS0", O_RDWR | O_NOCTTY | O_NDELAY);

if(fd_serialport == -1){
	perror("Unable to open /dev/ttyS0");
}

tcgetattr(fd_serialport, &options);
cfsetispeed(&options, B38400);
cfsetospeed(&options, B38400);
options.c_cflag |= (CLOCAL | CREAD);	
options.c_cflag |= PARENB;
options.c_cflag |= PARODD;
options.c_cflag &= ~CSTOPB;
options.c_cflag &= ~CSIZE;
options.c_cflag |= CS8;
options.c_iflag |= (INPCK | ISTRIP);
tcsetattr(fd_serialport, TCSANOW, &options);
	
fcntl(fd_serialport, F_SETFL, FNDELAY);

while(read(fd_serialport, &data_in[0], sizeof(char))){
		
	printf("%s\n",&data_in[0]);
	usleep(2000);
}

Ok, I think I partially figured this out. If I automatically set the variable to '\0' after reading one character, and then add an if statement to check this, it seems to work the way I need it. HOWEVER, there are characters sent that actually are 0 (0x00), that I need to see. If I set the var to '\0' after reading, when input is read that actually is 0 (and valid), these characters are ignored:

Code:

while(read(fd_serialport, &data_in[0], sizeof(char))){
		
	if(data_in[0] != '\0'){
		printf("%02x\n",data_in[0]);
	}
	data_in[0] = '\0'; //reset and wait for next char
}

I think I figured it out. I used select() to determine if new data was available (by checking FD_ISSET), then read(). It seems to be working OK.

Another way is to setup the read() to block until new characters are available in the serial input buffer:

Code:

fcntl(fd_serialport, F_SETFL, 0);         /* causes read to block until new characters are present */
fcntl(fd_serialport, F_SETFL, FNDELAY);   /* remove this call as it causes read to return immediately */

Originally Posted by itCbitC

Another way is to setup the read() to block until new characters are available in the serial input buffer:

Code:

fcntl(fd_serialport, F_SETFL, 0);         /* causes read to block until new characters are present */
fcntl(fd_serialport, F_SETFL, FNDELAY);   /* remove this call as it causes read to return immediately */

Ah, I see what's going on here. Opening a file descriptor with the O_NONBLOCK flag set won't wait for input before continuing the loop. That's why I had to use select(), which I'm realizing now was unnecessary. Thanks for clearing that up.

I've also discovered the following:

If using non-blocking I/O, you will need to implement your own checks to confirm the completion of reads/writes. I've found a few ways of doing this. One is the way you just mentioned (which seems to be the simplest), using read() with blocking I/O flags set. Second is using a non-blocking file descriptor with select() to check for completed reads. Yet another is using a non-blocking file descriptor flagged with O_ASYNC along with signal(), checking for SIGIO:

Code:

fcntl(fd_serialport, F_SETOWN, getpid());
fcntl(fd_serialport, F_SETFL, O_ASYNC);

I think I'll just stick with plain old blocking mode. It seems to work reliably.

The serial port "module" runs in its own thread, using non-blocking I/O (O_NONBLOCK) and select(). I passed a struct to the thread that contains the stuff that the thread needs to update (based on serial input) for the purpose of controlling the main thread:

Code:

void		*do_serial_control(void *args); //prototype for ctrl thread

struct SERIALCTRL {
	int	device_status;
	char	timecode[4];
};

struct		SERIALCTRL serial_control;

pthread_create(&thread1, NULL, do_serial_control, (void*)&serial_control);

do_serial_control() communicates with the main thread by taking serial port input and updating vars in the main thread via the the struct. These vars are constantly checked in the main loop.

Seems to be working well so far! Thanks for the help!

Curious if you made it non-blocking by setting a timeout in the struct timeval member??

Originally Posted by itCbitC

Curious if you made it non-blocking by setting a timeout in the struct timeval member??

I didn't have to do this because the machine is being queried via the serial port constantly. So, I just passed NULL as the last argument to select(). From what I can tell, this effectively throttles the reads off the serial port based on the speed that the remote machine is sending queries. And since it's running in its own thread, this doesn't tie up the main thread, which is constantly checking variables updated from the serial port reader thread (via a loop) and performing the main program functions.

Originally Posted by synthetix

I didn't have to do this because the machine is being queried via the serial port constantly. So, I just passed NULL as the last argument to select(). From what I can tell, this effectively throttles the reads off the serial port based on the speed that the remote machine is sending queries. And since it's running in its own thread, this doesn't tie up the main thread, which is constantly checking variables updated from the serial port reader thread (via a loop) and performing the main program functions.

Reason to have a timeout is to prevent the select from blocking otherwise it'll just sit there and wait for input exactly like the call below:

Code:

fcntl(fd_serialport, F_SETFL, 0);

Is your application doing anything else besides reading from that serial port? Are there many ports to read from?
The power of select() is in its ability to poll each file descriptor in turn, waiting for an event or else timing out.