Vfrdtyky

I borrowed much of the following code from the Linux Serial HOWTO pages to create my program to read characters endlessly from the serial port. I'm using a USB to serial port adapter (made by micro innovations) so I can get a serial port. Linux recognizes the device as /dev/ttyUSB0.

When I use the device in other native linux programs (such as the output dump program), the adapter works flawlessly and data continuously comes in. However, with my program, the data comes in for roughly 10 seconds, then I receive no more data, yet I know the hardware that the adapter is connected to has more data to process.

Is there something in this code I can fix to allow me to receive unlimited characters as they arrive without me having to restart the program to receive more characters?

I still want to make the mainline code asynchronous to the serial routine as I will be adding more code later on.

#include <termios.h>

#include <stdio.h>

#include <unistd.h>

#include <fcntl.h>

#include <sys/signal.h>

#include <sys/types.h>



#define BAUDRATE B57600

#define MODEMDEVICE "/dev/ttyUSB0" /* My USB to serial converter */

#define _POSIX_SOURCE 1 /* POSIX compliant source */

#define FALSE 0

#define TRUE 1



void signal_handler_IO ();   /* definition of signal handler */

int wait_flag=TRUE;          /* TRUE while no signal received */



int main(){

  int fd,res;

  struct termios oldtio,newtio;

  struct sigaction saio;           /* definition of signal action */

  char buf[255];



  /* open the device */

  fd = open(MODEMDEVICE, O_RDWR | O_NOCTTY);

  if (fd <0) {perror(MODEMDEVICE); return -1; }



  /* install the signal handler before making the device asynchronous */

  saio.sa_handler = signal_handler_IO;

  saio.sa_flags=0;

  saio.sa_restorer = NULL;

  sigaction(SIGIO,&saio,NULL);



  /* allow the process to receive SIGIO */

  fcntl(fd, F_SETOWN, getpid());

  /* Make the file descriptor asynchronous */

  fcntl(fd, F_SETFL, FASYNC);



  tcgetattr(fd,&oldtio); /* save current port settings */

  /* set new port settings for canonical input processing */

  newtio.c_cflag = BAUDRATE | CRTSCTS | CS8 | CLOCAL | CREAD;

  newtio.c_iflag = IGNPAR | ICRNL;

  newtio.c_oflag = 0;

  newtio.c_lflag = ICANON;

  newtio.c_cc[VMIN]=1;

  newtio.c_cc[VTIME]=0;

  tcflush(fd, TCIFLUSH);

  tcsetattr(fd,TCSANOW,&newtio);



  /* loop while waiting for input. */

  while (1) {

    usleep(100000);

    /* after receiving SIGIO, wait_flag = FALSE, 

    input is available and can be read */

    if (wait_flag==FALSE) { 

      res=0;

      /* Read up to 11 bytes which is remote packet length if file handle is valid */

      if (fd){

        res = read(fd,buf,11);

      }

      /* If there's at least 2 bytes (character plus ending null) then process it */

      if (res > 1){

        int n;

        /* Print each character as 2-digit hex  even if value is 0. */

        for (n=0;n<(res-1);n++){

          printf("%2X ",(unsigned char)buf[n]);

        }

        /* Print total number of characters received */

        printf(" = %dn",res);

      }

      wait_flag = TRUE;      /* wait for new input */

    }

    /* Return to start of endless loop */

  }

  return 0;

}



/***************************************************************************

* signal handler. sets wait_flag to FALSE, to indicate above loop that     *

* characters have been received.                                           *

***************************************************************************/



void signal_handler_IO ()

{

wait_flag = FALSE;

}

Classic race condition:

The signal_handler_IO() may be called before your code sets wait_flag = TRUE; e.g. during those printf() calls.

At this point your program will simply stop.

A remedy could be setting the wait_flag immediately after the if - but I would recommend looking into linux poll() call for async I/O.