Linux应用编程之串口操作20170901

主要介绍在Linux应用程序下对串口的操作：

1.串口初始化

int InitCom()

{

         int Ret;

             Ret = SerailComm.OpenCom( ComPortDevPath, 0 );

             if( Ret < 0 )

             {

                 return Ret;

             }

         if(SerailComm.SetComSpeed( ComBaudRate ) < 0 )

         {

                   SerailComm.CloseCom();

                   return Ret;

         }

         if(SerailComm.SetComParity(8, 1, 'N', 0, 0) < 0)

         {

                   SerailComm.CloseCom();

                   return Ret;

         }

         Ret = SerailComm.SetComRawMode();

         if( Ret < 0 )

         {

                   SerailComm.CloseCom();

                   return  Ret;

         }

         if( SerailComm.SetComSelectTimeOut(1, 0, READ_TIMEOUT_F) < 0 )

         {

                   CloseCom();

                 return  Ret;

         }

         if( SerailComm.SetComSelectTimeOut( 0, 500000, WRITE_TIMEOUT_F) < 0 )

         {

                   SerailComm.CloseCom();

                 return  Ret;

         }

         SerailComm.SetSerialCommBlock( 0 );

     return 0;

}

2.读数据

int ReadCom()

{

         char cRecvBuf[256];

         int iBufSize = 256;

         memset(cRecvBuf, 0, sizeof(cRecvBuf));

         return SerailComm.ReadBinCom(cRecvBuf, iBufSize))

}

3.写数据

int WriteCom(u8 *WriteBuf, int Size)

{

    return SerailComm.WriteBinCom((char*)WriteBuf, Size);

}

4.关闭串口

void CloseCom()

{

    SerailComm.CloseCom();

}

5.附：上述使用到的串口类

#include "ComTransmit.h"
#include <assert.h>
#include <unistd.h>
#include <termios.h>
#include <ctype.h>
#include <errno.h>

#include "tracelevel.h"
#include "MdvrModulCom.h"

extern HANDLE_DVR  g_hDvr;

pthread_mutex_t ComCommutex = PTHREAD_MUTEX_INITIALIZER;

//pthread_rwlock_t  rwlock = PTHREAD_RWLOCK_INITIALIZER;

speedPara speed_atr[] =
{
    {B300,300},
    {B600,600},
    {B1200,1200},
    {B2400,2400},
    {B4800,4800},
    {B9600,9600},
    {B19200,19200},
    {B38400,38400},
    {B57600,57600},
    {B115200,115200}    ,
    {B230400,230400}
};

CComTransmit::CComTransmit():m_fp(NULL),m_fd(-1)
{
    memset(&Rtimeout,0,sizeof(Rtimeout));
    memset(&Wtimeout,0,sizeof(Wtimeout));
    m_binit = 0;
}

CComTransmit::~CComTransmit()
{

}

int CComTransmit::OpenCom(const char * deviceName, int isMutex)
{
    assert(deviceName != NULL);

    if(m_binit == 1)
        return 0;

    m_fd = open(deviceName,O_RDWR);
    if(m_fd < 0)
    {
        printf("Open Com [%s] failure! %s
",deviceName, strerror(errno));
        return -1;
    }

    printf("Open Com [%s] Sucess
",deviceName);

    m_fp = fdopen(m_fd, "r+b");
    if(m_fp == NULL)
    {
        return -1;
    }

    m_binit = 1;
    m_mutex_flag = isMutex;

    return 0;
}

void CComTransmit::CloseCom()
{
    int ret = close(m_fd);
    if(ret < 0)
    {
        printf("close Com failure!
");
    }
    m_fp = NULL;
    m_binit = 0;
}

int CComTransmit::SetComSpeed(unsigned int speed)
{
    int comspeed = 0;
    int status = 0;
    struct termios   Opt;
    int ret = -1;

    for(unsigned int i = 0;i < sizeof(speed_atr)/sizeof(speedPara);i++)
    {
        if(speed == speed_atr[i].userSpeed)
        {
            comspeed = speed_atr[i].sysSpeed;
            break;
        }
    }

    if(!comspeed)
    {
        assert(comspeed != 0);
    }

    if(m_fd < 0)
    {
        return -1;
    }
    tcgetattr(m_fd, &Opt);
    tcflush(m_fd, TCIOFLUSH);
        ret = cfsetispeed(&Opt, comspeed);
    if(ret < 0)
    {
        perror("set input speed error!
");
        return -1;
    }

        ret = cfsetospeed(&Opt, comspeed);
    if(ret < 0)
    {
        perror("set output speed error!
");
        return -1;
    }

        status = tcsetattr(m_fd, TCSANOW, &Opt);
        if(status != 0)
        {
                perror("tcsetattr fd1");
        return -1;
        }

    tcflush(m_fd,TCIOFLUSH);
    return 0;
 }

int CComTransmit::SetComParity(int databits, int stopbits, int parity,int flowctrl, int Rs485)
{
    struct termios options;

    if(m_fd < 0)
    {
        return -1;
    }

    if  ( tcgetattr( m_fd,&options)  !=  0)
    {
        printf("SetComParity 1");
        return-1;
    }

    options.c_cflag &= ~CSIZE;
      switch (databits) /*设置数据位数*/
      {
          case 5:
            options.c_cflag |= CS5;
            break;
        case 6:
            options.c_cflag |= CS6;
            break;
          case 7:
              options.c_cflag |= CS7;
              break;
          case 8:
            options.c_cflag |= CS8;
            break;
        default:
            fprintf(stderr,"Unsupported data size
");
            return -1;
    }
      switch (parity)
      {
          case 'n':
        case 'N':
        case 0:
            options.c_cflag &= ~PARENB;   /* Clear parity enable */
            options.c_iflag &= ~INPCK;     /* Enable parity checking */
            break;
        case 'o':
        case 'O':
        case 1:
            options.c_cflag |= (PARODD | PARENB);  /* 设置为奇效验*/
            options.c_iflag |= INPCK;             /* Disnable parity checking */
            break;
        case 'e':
        case 'E':
        case 2:
            options.c_cflag |= PARENB;     /* Enable parity */
            options.c_cflag &= ~PARODD;   /* 转换为偶效验*/
            options.c_iflag |= INPCK;       /* Disnable parity checking */
            break;
        case 'S':
        case 's':  /*as no parity*/
            options.c_cflag &= ~PARENB;
            options.c_cflag &= ~CSTOPB;
            break;
        default:
            fprintf(stderr,"Unsupported parity
");
            return -1;
        }

      /* 设置停止位*/
      switch (stopbits)
      {
          case 1:
              options.c_cflag &= ~CSTOPB;
            break;
        case 2:
            options.c_cflag |= CSTOPB;
        break;
        default:
            fprintf(stderr,"Unsupported stop bits
");
            return (-1);
    }

    switch(flowctrl)    /* 设置流控制*/
    {
        case 0:
            options.c_cflag &= ~CRTSCTS;   /*no flow control*/
            break;
        case 1:
            options.c_cflag |= CRTSCTS;    /*hardware flow control*/
            break;
        case 2:
            options.c_cflag |= IXON|IXOFF|IXANY; /*software flow control*/
            break;
        default:
            options.c_cflag &= ~CRTSCTS;   /*no flow control*/
            break;
    }
#if 0
    if(Rs485)
    {
        options.c_cflag |= (0x00000001<<23);
    }
    else
    {
        options.c_cflag &= (~(0x00000001<<23));
    }
#else

    PRODUCT_INFO_ST productInfo;

     EX_GetProductInfo(g_hDvr, &productInfo);
     if((productInfo.productTypeID == MDVR_JH6S8_720P)||(productInfo.productTypeID == MDVR_JH6S4_720P))
     {
         if(Rs485)
         {
             options.c_cflag |= (0x00000001<<30);
         }
         else
         {
             options.c_cflag &= (~(0x00000001<<30));
         }

     }
#endif
      /* Set input parity option */
      if (parity != 'n')
          options.c_iflag |= INPCK;

        options.c_cc[VTIME] = 10; // 1 seconds
        options.c_cc[VMIN] = 0;

      tcflush(m_fd,TCIFLUSH); /* Update the options and do it NOW */
      if (tcsetattr(m_fd,TCSANOW,&options) != 0)
      {
          perror("SetComParity 2");
        return (-1);
    }

      return (0);
}

//0---read ,1--write
int CComTransmit::SetComSelectTimeOut(int sec,int usec,SELECT_TIMEOUT_F rwflag)
{
    if(rwflag == WRITE_TIMEOUT_F)
    {
        Wtimeout.tv_sec = sec;
        Wtimeout.tv_usec = usec;
    }
    else
    {
        Rtimeout.tv_sec = sec;
        Rtimeout.tv_usec = usec;
    }

    return 0;
}

int CComTransmit::IOFlush()
{
    tcflush(m_fd, TCIOFLUSH);
    return 0;
}

int CComTransmit::SetComRawModeEx()
{
    int ret = 0;
    struct termios options;

    tcgetattr(m_fd, &options);

    tcflush(m_fd, TCIOFLUSH);
    options.c_cflag &= ~CSIZE;
    options.c_cflag |= CS8;
    options.c_cflag &= ~PARENB;
    options.c_cflag &= ~CSTOPB;
    options.c_cflag &= ~CSTOPB;
    options.c_oflag  &= ~OPOST;

#if 0
    printf("before iflag %x, lflag %x, oflag  %x 
", options.c_iflag, options.c_lflag, options.c_oflag);

//    options.c_lflag = 0 ;
//    options.c_oflag = 0 ;
//    options.c_iflag = 0;
    options.c_lflag &= ~(ICANON |ISIG);
    options.c_iflag &= ~(ICRNL|IGNCR);

          //options.c_iflag |= (IGNBRK|BRKINT);
          options.c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);

    printf("iflag %x, lflag %x, oflag  %x 
", options.c_iflag, options.c_lflag, options.c_oflag);

#endif

    //|PARMRK|ISTRIP|IGNCR|ICRNL|IXON|INLCR
    tcflush(m_fd, TCIFLUSH);
    options.c_cc[VTIME] = 0; //128;
    options.c_cc[VMIN] = 1;// 1;

    cfmakeraw(&options);

    ret = tcsetattr(m_fd,TCSANOW,&options);
    if (ret < 0)
    {
        perror("set raw mode error!");
        return ret;
    }

    return 0;
}

int CComTransmit::SetComRawMode()
{
    int ret = 0;
    struct termios options;

    tcgetattr(m_fd, &options);

    cfmakeraw(&options);
    ret = tcsetattr(m_fd,TCSANOW,&options);
    if (ret < 0)
    {
        perror("set raw mode error!");
    }

    return ret;
}

int CComTransmit::ReadCom(char *ReadBuffer,int size,int *retSize)
{
    int retval = -1;

    fd_set serial;
    struct timeval rdtimeout;
    *retSize = 0;
    if(m_fd < 0)
    {
        fprintf(stderr,"%s[%d]:serial have not open!
",__FILE__,__LINE__);
        return -1;
    }

    FD_ZERO(&serial);
    FD_SET(m_fd, &serial);
    rdtimeout = Rtimeout;
#if 1

    do{
        retval = select(m_fd+1,  &serial, NULL, NULL, &rdtimeout);
        if(retval < 0)
        {
            if(errno == EINTR)
            {
                //printf("select Interruppter!
");
            }
            else
            {
                break;
            }
        }
    }while(retval == -1);

    if(retval <= 0)
    {
        return -1;
    }

     //读数据写BUFFER
    if(FD_ISSET(m_fd, &serial)!=0)
    {
        if(NULL != m_fp)
        {
            if(m_mutex_flag)
            {
                pthread_mutex_lock(&ComCommutex);
                fgets(ReadBuffer, size, m_fp);
                pthread_mutex_unlock(&ComCommutex);
            }
            else
            {
                fgets(ReadBuffer, size, m_fp);
            }
            *retSize = strlen(ReadBuffer);
        }
    }
    return 0;
#else
        if(m_fd > 0)
        {
            retval = read(m_fd, ReadBuffer, size);
        }

        if(retval > 0)
        {
            *retSize = retval;
        }
        else
        {
            *retSize = 0;
        }

        return retval;

#endif
}

int CComTransmit::ReadComEx( char *ReadBuffer,int size,int *retSize )
{
    fd_set     read_fds;
    int     retval;
    struct timeval rdtimeout;

    rdtimeout.tv_sec  = Rtimeout.tv_sec;
    rdtimeout.tv_usec = Rtimeout.tv_usec;

    if(m_fd < 0)
    {
        fprintf(stderr,"%s[%d]:serial have not open!
",__FILE__,__LINE__);
        return -1;
    }

    FD_ZERO(&read_fds);
    FD_SET(m_fd, &read_fds);

    retval = select(m_fd + 1,  &read_fds, NULL, NULL, &rdtimeout);
    if( retval <= 0 )
    {
        return -1;
    }

    if ( !FD_ISSET(m_fd, &read_fds) )
    {
        //printf("Serail Com[%s] read time out[%d]
", m_SerialPath, time_out);
        return -1;
    }

    retval = read(m_fd, ReadBuffer, size);
    *retSize = retval;

    if(*retSize < 0)
    {
        return -1;
    }

    return 0;
}


/*
*函数功能:读取串口binary数据
*创建作者:freeman on 2010/0818
*/
int CComTransmit::ReadBinCom(char *ReadBuffer,int size)
{
    int retval = -1;

#if 0

    fd_set serial;
    struct timeval rdtimeout;

    if(m_fd < 0)
    {
        fprintf(stderr,"%s[%d]:serial have not open!
",__FILE__,__LINE__);
        return -1;
    }

    FD_ZERO(&serial);
    FD_SET(m_fd, &serial);
    rdtimeout = Rtimeout;

    do{
        retval = select(m_fd+1,  &serial, NULL, NULL, &rdtimeout);
        if(retval < 0)
        {
            if(errno == EINTR)
            {
                //printf("select Interruppter!
");
            }
            else
            {
                break;
            }
        }
    }while(retval == -1);

    if(retval <= 0)
    {
        return -1;
    }

     //读数据写BUFFER
    if(FD_ISSET(m_fd,&serial)!=0)
    {
        if(NULL != m_fp)
        {
            return  read(m_fd,ReadBuffer,size);
        }
    }
    return 0;

#else

    if(m_fd > 0)
    {
        retval = read(m_fd, ReadBuffer, size);
    }
    else
    {
        TRACE_NET(ERR,"ReadBinCom ERR:%d
",m_fd);
    }
    return retval;

#endif
}


int CComTransmit::WriteCom(char *WriteBuffer,int size)
{
    int     ret = -1;
#if 1
    fd_set serial;
    int retval =0;
    struct timeval WTtimeout;

    if(m_fd < 0)
    {
        TRACE_NET(ERR, "---serial have not open!
");
        return -1;
    }

//    printf("Snd Com %s  
", WriteBuffer);

    FD_ZERO(&serial);
    FD_SET(m_fd, &serial);
    WTtimeout = Wtimeout;
    if ((retval = select(m_fd+1,  NULL, &serial, NULL, &WTtimeout)) < 0)
    {
        TRACE_NET(ERR, "select error! ---- 
");
        return -1;
    }

    if(retval == 0)
    {
        TRACE_NET(ERR, "select timeout! ---- 
");
        return -1;
    }

    //读数据写BUFFER
    if(FD_ISSET(m_fd,&serial)!=0)
    {
        pthread_mutex_lock(&ComCommutex);
        ret = write(m_fd, WriteBuffer ,size);
        pthread_mutex_unlock(&ComCommutex);

        if(ret == -1)
        {
            TRACE_NET(ERR, "serial send data failed -----!
");
            return  -1;
        }
    }

    return ret;
#else
    ret = write(m_fd, WriteBuffer ,size);
    //      printf("Send cmd %d  
", ret);
    if(ret == -1)
    {
        printf("serial send data failed -----error!
");
        return  -1;
    }
    return ret;

#endif
}

int CComTransmit::WriteBinCom(char *WriteBuffer,int size)
{
    int     ret = -1;
#if 0
    fd_set serial;
       int retval =0;
    struct timeval WTtimeout;

    if(m_fd < 0)
    {
        fprintf(stderr,"%s:%d---serial have not open!
", __FILE__, __LINE__);
        return -1;
    }

//    printf("Snd Com %s  
", WriteBuffer);

       FD_ZERO(&serial);
       FD_SET(m_fd, &serial);
    WTtimeout = Wtimeout;
       if ((retval = select(m_fd+1,  NULL, &serial, NULL, &WTtimeout)) < 0)
    {
              fprintf(stderr,"%s[%d]:select error!---------------
",__FILE__,__LINE__);
        return -1;
       }

    if(retval == 0)
    {
        fprintf(stderr,"%s[%d]:select timeout!---------------
",__FILE__,__LINE__);
        return -1;
    }

    //读数据写BUFFER
       if(FD_ISSET(m_fd,&serial)!=0)
    {
        pthread_mutex_lock(&Commutex);
                 ret = write(m_fd, WriteBuffer ,size);
        pthread_mutex_unlock(&Commutex);

        if(ret == -1)
        {
            printf("serial send data failed -----error!
");
            return  -1;
        }
    }

        return ret;
#else
    if(m_fd > 0)
    ret = write(m_fd, WriteBuffer ,size);
    //       printf("Send cmd %d  
", ret);
    if(ret == -1)
    {
        TRACE_NET(ERR, "serial send data failed -----!
");
        return  -1;
    }

    return ret;
#endif
}


int CComTransmit::GetPortFD()
{
    return m_fd;
}

FILE* CComTransmit::GetPortFP()
{
    return m_fp;
}

void  CComTransmit::SetSerialCommBlock(int isBlock)
{
    int    nFlags = fcntl(m_fd, F_GETFL, 0);

    if(isBlock)
    {
        fcntl(m_fd, F_SETFL, 0);
    }
    else
    {
        fcntl(m_fd, F_SETFL, nFlags|O_NONBLOCK);
    }
}


int CComTransmit::ReadComWithBuf(char *ReadBuffer,int size,int *retSize)
{
    fd_set serial;
    int retval;
    struct timeval rdtimeout;
    *retSize = 0;
    int left = 0;
    int recvlen = 0;

    if(m_fd < 0)
    {
        fprintf(stderr,"%s[%d]:serial have not open!
",__FILE__,__LINE__);
        return -1;
    }

    for(int i = 0;i < size - 1 && i < m_len;i++)
    {
        ReadBuffer[i] = m_buf[i];
        if(m_buf[i] == '
')
        {
            ReadBuffer[i+1] = 0;
            memmove(m_buf,&m_buf[i+1],m_len-(i+1));
            m_len -= (i+1);
            *retSize = i+1;
            return *retSize;
        }
    }

    FD_ZERO(&serial);
    FD_SET(m_fd, &serial);
    rdtimeout = Rtimeout;

    do{
        retval = select(m_fd+1,  &serial, NULL, NULL, &rdtimeout);
        if(retval < 0)
        {
            if(errno == EINTR)
            {
                //printf("select Interruppter!
");
            }
            else
            {
                break;
            }
        }
    }while(retval == -1);

    if(retval <= 0)
    {
        return -1;
    }

     //读数据写BUFFER
    if(FD_ISSET(m_fd,&serial)!=0)
    {
        if(NULL != m_fp)
        {
            left = SERIAL_BUF_LEN - m_len;
            if(left > 0)
            {
                recvlen = read(m_fd,&m_buf[m_len],left);
                if(recvlen > 0)
                {
                    m_len += recvlen;
                }
            }
            else
            {
        //        WRITE_DBG_LOG("串口接收数据512字节内没有换行符号");
                m_buf[m_len-1] = 0;
        //        WRITE_DBG_LOG("%s",m_buf);
                m_len = 0;
                left = SERIAL_BUF_LEN;
                recvlen = read(m_fd,&m_buf[m_len],left);
                if(recvlen > 0)
                {
                    m_len += recvlen;
                }
            }

            for(int i = 0;i < size - 1 && i < m_len;i++)
            {
                ReadBuffer[i] = m_buf[i];
                if(m_buf[i] == '
')
                {
                    ReadBuffer[i+1] = 0;
                    memmove(m_buf,&m_buf[i+1],m_len-(i+1));
                    m_len -= (i+1);
                    *retSize = i+1;
                    return *retSize;
                }
            }
        }
    }

    return -1;
}

#ifndef _COM_TRANSMIT_H_
#define _COM_TRANSMIT_H_

#include <string.h>
#include <pthread.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>

#define SERIAL_BUF_LEN  512

typedef struct {
    unsigned long         baudrate;    /*波特率*/
    unsigned char         databit;        /*数据位，取值5、6、7、8*/
    unsigned char         parity;        /*奇偶校验位，取值'n':无校验'o':奇校验'e'偶校验*/
    unsigned char         stopbit;        /*停止位，取值1,2*/
    unsigned char         reserve;        /*保留字节*/
}Terminal;

typedef struct
{
    int  sysSpeed;
    unsigned long  userSpeed;
}speedPara;

typedef enum
{
    READ_TIMEOUT_F = 0,
    WRITE_TIMEOUT_F
}SELECT_TIMEOUT_F;

class CComTransmit
{
private:
    //
    FILE     *m_fp;
    int         m_fd;
    int        m_mutex_flag;
    struct timeval Rtimeout;
    struct timeval Wtimeout;
    int     m_binit;
    char    m_buf[SERIAL_BUF_LEN];
    int        m_len;

public:
    //
    CComTransmit();
    ~CComTransmit();
    int OpenCom(const char *deviceName, int isMutex = 1);
    void CloseCom();
    int SetComSpeed(unsigned int speed);
    int SetComParity(int databits, int stopbits, int parity,int flowctrl, int Rs485);
    int SetComRawMode();
    int SetComRawModeEx();
    int SetComSelectTimeOut(int sec,int usec,SELECT_TIMEOUT_F RWflag);//0--read,1--wirte
    int IOFlush();
    int ReadCom(char *ReadBuffer,int size,int *retSize);
    int ReadComEx( char *ReadBuffer,int size,int *retSize );
    int ReadBinCom(char *ReadBuffer,int size);
    int WriteCom(char *WriteBuffer,int size);
    int WriteBinCom(char *WriteBuffer,int size);

    int GetPortFD();
    FILE* GetPortFP();
    void  SetSerialCommBlock(int isBlock);
    int ReadComWithBuf(char *ReadBuffer,int size,int *retSize);


protected:
    //
};

#endif//_COM_TRANSMIT_H_