Simple linux serial port programming in C.

It is very often to use minicom, putty and gtkterm.. and so forth program to communicate the other device by serial port.

  It is interest to know how to use c code to control the serial port.


My C code be below:

/*refer to 
* http://stackoverflow.com/questions/6947413/how-to-open-read-and-write-from-serial-port-in-c
* http://www.tldp.org/HOWTO/Serial-Programming-HOWTO/x115.html
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#include <fcntl.h>
#include <termios.h> /*termio.h for serial IO api*/ 

#include <pthread.h>    /* POSIX Threads */

#define MAX_STR_LEN       256

/*
 * The values for speed are 
 * B115200, B230400, B9600, B19200, B38400, B57600, B1200, B2400, B4800, etc
 * 
 *  The values for parity are 0 (meaning no parity), 
 * PARENB|PARODD (enable parity and use odd), 
 * PARENB (enable parity and use even), 
 * PARENB|PARODD|CMSPAR (mark parity), 
 * and PARENB|CMSPAR (space parity).
 * */
 
 
int SetInterfaceAttribs(int fd, int speed, int parity)
{
        struct termios tty;
        memset (&tty, 0, sizeof tty);
        if (tcgetattr (fd, &tty) != 0) /* save current serial port settings */
        {
   printf("__LINE__ = %d, error %s\n", __LINE__, strerror(errno));
            return -1;
        }

        cfsetospeed (&tty, speed);
        cfsetispeed (&tty, speed);

        tty.c_cflag = (tty.c_cflag & ~CSIZE) | CS8;     // 8-bit chars
        // disable IGNBRK for mismatched speed tests; otherwise receive break
        // as \000 chars
        tty.c_iflag &= ~IGNBRK;         // disable break processing
        tty.c_lflag = 0;                // no signaling chars, no echo,
                                        // no canonical processing
        tty.c_oflag = 0;                // no remapping, no delays
        tty.c_cc[VMIN]  = 1;            // read doesn't block
        tty.c_cc[VTIME] = 0;            // 0.5 seconds read timeout

        tty.c_iflag &= ~(IXON | IXOFF | IXANY); // shut off xon/xoff ctrl

        tty.c_cflag |= (CLOCAL | CREAD);// ignore modem controls,
                                        // enable reading
        tty.c_cflag &= ~(PARENB | PARODD);      // shut off parity
        tty.c_cflag |= parity;
        tty.c_cflag &= ~CSTOPB;
        tty.c_cflag &= ~CRTSCTS;

        if (tcsetattr (fd, TCSANOW, &tty) != 0)
        {
                printf("__LINE__ = %d, error %s\n", __LINE__, strerror(errno));
                return -1;
        }
        return 0;
}/*set_interface_attribs*/


void SetBlocking(int fd, int should_block)
{
        struct termios tty;
        memset (&tty, 0, sizeof tty);
        if (tcgetattr(fd, &tty) != 0)
        {
                printf("__LINE__ = %d, error %s\n", __LINE__, strerror(errno));
                return;
        }

        tty.c_cc[VMIN]  = should_block ? 1 : 0;
        tty.c_cc[VTIME] = 5;            // 0.5 seconds read timeout

        if (tcsetattr (fd, TCSANOW, &tty) != 0)
                 printf("__LINE__ = %d, error %s\n", __LINE__, strerror(errno));
}/*SetBlocking*/


void *sendThread(void *parameters)
{
 char sendBuff[MAX_STR_LEN];
 
 memset(&sendBuff[0], 0, MAX_STR_LEN);
 snprintf(&sendBuff[0], MAX_STR_LEN, "hello!");
 
 int fd;
 
 fd = *((int*)parameters);
 
 while(1)
 {
  write(fd, &sendBuff[0], strlen(&sendBuff[0]) ); 
 
  // sleep enough to transmit the length plus receive 25:  
  // approx 100 uS per char transmit
  usleep((strlen(&sendBuff[0]) + 25) * 100);     
 
  usleep(500*1000);        
 }/*while*/
 
 pthread_exit(0); 
}/*sendThread */


void *readThread(void *parameters)
{
 char readBuff[MAX_STR_LEN];
 
 int fd;
 
 fd = *((int*)parameters);
 
 while(1)
 {
  ssize_t len;
  
  memset(&readBuff[0], 0, MAX_STR_LEN);
 
  len = read(fd, &readBuff[0], MAX_STR_LEN); 
 
  if (-1 == len)
  { 
   switch(errno) 
   {
    case EAGAIN:
    printf("__FUNCTION__ = %s, __LINE__ = %d\n", __FUNCTION__, __LINE__);
    usleep(5*1000); 
    continue;
    break;
    
    default:
    printf("__FUNCTION__ = %s, __LINE__ = %d\n", __FUNCTION__, __LINE__);
     pthread_exit(0); 
    break;  
   }
  }
  
  if(0 == len) 
  {
   printf("devic is lost!\n"); /*device maybe be unplugged*/
   exit(0); 
  }/*if*/ 
    
  
  
  // sleep enough to transmit the length plus receive 25:  
  // approx 100 uS per char transmit
  usleep((len + 25) * 100);
  printf("len = %d\n", (int)len);
  
  int i;
  
  for(i = 0; i< len; i++)
   printf("%c(%d %#x)\t", readBuff[i], readBuff[i], readBuff[i]);
   
  printf("\n");    
 }/*while*/
 
 pthread_exit(0); 
}/*readThread */


int main(int argc, char *argv[])
{
 int fd, c, res;
 struct termios oldtio,newtio;
 char buf[MAX_STR_LEN];
 int k;
 char deviceName[MAX_STR_LEN];
 
 
 memset(&deviceName[0], 0, MAX_STR_LEN);
 snprintf(&deviceName[0], MAX_STR_LEN, "/dev/ttyUSB0");
 
 k = 1;
 while(argc > k)
 { 
  if(0 == strncmp(argv[k], "-d", MAX_STR_LEN))
  {
   if(k + 1 < argc)
   {
    snprintf(&deviceName[0], MAX_STR_LEN, "%s", argv[k + 1]);
   }
   else
   {
    printf("error : -d should be follow a device!\n");  
    return 0;
   }/*if */
  }
  k++; 
 }/*while k*/
 
 printf("__FUNCTION__ = %s, __LINE__ = %d\n", __FUNCTION__, __LINE__);
 
 //non-blocking mode
 //fd = open(&deviceName[0], O_RDWR | O_NOCTTY |O_NONBLOCK| O_NDELAY); 
 
 fd = open(&deviceName[0], O_RDWR | O_NOCTTY); 
 if(0 > fd) 
 {
  perror(&deviceName[0]); 
  exit(-1); 
 }/*if */
 
 
 SetInterfaceAttribs(fd, B115200, 0); /* set speed to 115,200 bps, 8n1 (no parity)*/
 SetBlocking(fd, 1); 
 
 pthread_t readThread_t, sendThread_t;  /* thread variables */
 
 pthread_create(&readThread_t, NULL, (void *)readThread, (void *)&fd);
 pthread_create(&sendThread_t, NULL, (void *)sendThread, (void *)&fd);
 
 pthread_join(readThread_t, NULL);   
 pthread_join(sendThread_t, NULL);
 
 close(fd);
 
 return 0;
}/*main*/

 the code would send "hello" string to the uart (Universal Asynchronous Receiver/Transmitter) per 500 milli-second, and print data which have been received.