multithreadserial.cpp

Linux下的一个多线程串口收发程序。应该相当好的。如有什么BUG请通过邮箱通知我

#include <math.h>
#include "MultiThreadSerial.h"

static const char* DEVPATH = "/dev/ttyS";
static const char* DEVPATHS = "/dev/tty";

PVOID ComProc( PVOID param )
{
    int i = 0;
    fd_set  rd;
    
    CMultiThreadSerial* pComm = (CMultiThreadSerial*)param;
    
    FD_ZERO( &rd );
    FD_SET( pComm->m_SerialFD, &rd );
    while ( pComm->m_bIsOpen )
    {
        while ( FD_ISSET( pComm->m_SerialFD, &rd ) )
        {
            if ( select( pComm->m_SerialFD+1, &rd, NULL, NULL, NULL ) < 0 )
            {
                printf( "error!\n" );
            }
            else
            {
                while ( pComm->ReadSerial( &pComm->m_nData.in_buf[pComm->m_nData.in_save], 1 ) > 0 )
                {
                    pComm->m_nData.in_save ++;
                    pComm->m_nData.in_save &= MIN_DATA_SIZE;
                }
            }
        }
    }
    pthread_exit( 0 );
}

CMultiThreadSerial::CMultiThreadSerial()
{
}

CMultiThreadSerial::~CMultiThreadSerial()
{
}

DWORD CMultiThreadSerial::WriteSerial( CPVOID pBuf, DWORD dwLength )   /*些串口数据*/
{
    return write( m_SerialFD, pBuf, dwLength );
}

DWORD CMultiThreadSerial::ReadSerial( PVOID pBuf, DWORD dwLength )
{
    return read( m_SerialFD, pBuf, dwLength );
}

bool CMultiThreadSerial::GetData( PBYTE pBuf, DWORD dwLength )
{
    int len, load;
    
    len = m_nData.in_save+MAX_DATA_SIZE-m_nData.in_load;
    len &= MIN_DATA_SIZE;
    if ( len < dwLength ) return false;
    
    len = 0;
    load = m_nData.in_load;
    while ( load != m_nData.in_save )
    {
        *pBuf = m_nData.in_buf[load];
        pBuf++;
        len++; load++; load &= MIN_DATA_SIZE;
        if( len >= dwLength ) break;
    }
    return (len == dwLength);
}

DWORD CMultiThreadSerial::GetDataCount()
{
    int count;

    count = m_nData.in_save+MAX_DATA_SIZE-m_nData.in_load;
    count &= MIN_DATA_SIZE;
    return count;
}

void CMultiThreadSerial::DropData( DWORD dwLength )
{
    m_nData.in_load += dwLength;
    m_nData.in_load &= MIN_DATA_SIZE;
}

bool CMultiThreadSerial::SerialOpen()
{
    pthread_t   id;
    int         ret;
    
    m_bIsOpen = true;
    ret = pthread_create( &id, NULL, ComProc, this );
    if ( ret < 0 ) return false;
    else return true;
}

bool CMultiThreadSerial::SerialClose()
{
    if ( isatty( m_SerialFD ) )
    {
        close( m_SerialFD );
        m_SerialFD = -1;
        m_bIsOpen = false;
        return true;
    }
    else return false;
}

bool CMultiThreadSerial::IsSerialOpen()
{
    return m_bIsOpen;
}

bool CMultiThreadSerial::SerialInit( int m_nComNo )        /*初始化串口*/
{
    char* strport = NULL;
    if ( m_nComNo > 0 && m_nComNo < 9 )
    {
        strport = (char*)malloc( sizeof(char)+1 );
        if ( strport != NULL ) strport = gcvt( m_nComNo, 1, strport );
    }
    else
    {
        strport = (char*)malloc( sizeof(char)*2+1 );
        if ( strport != NULL ) strport = gcvt( m_nComNo, 2, strport );
    }
    char* comname = (char*)malloc( strlen(DEVPATH)+strlen(strport)+1);
    if ( comname == NULL )
    {
        if ( strport != NULL )
        {
            free( strport );
            strport == NULL;
        }
        m_SerialFD = -1;
        return false;
    }
    strcpy( comname, DEVPATH );
    strcat( comname, strport );
    m_SerialFD = open( comname, O_RDWR|O_NOCTTY|O_NDELAY );
    free( comname );
    comname = NULL;
    if ( !isatty( m_SerialFD ) )
    {
        close( m_SerialFD );
        m_SerialFD = -1;
        return false;
    }
    return true;
}

bool CMultiThreadSerial::SerialInit( PCHAR m_nComName )    /*初始化串口*/
{
    if ( (m_nComName == NULL) || (!isalpha((int)*m_nComName) ) )
    {
        return false;
    }
    
    char* comname = (char*)malloc( strlen(DEVPATHS)+strlen(m_nComName)+1);
    if ( comname == NULL )
    {
        return false;
    }
    strcpy( comname, DEVPATHS );
    strcat( comname, m_nComName );
    m_SerialFD = open( comname, O_RDWR|O_NOCTTY|O_NDELAY );
    free( comname );
    comname = NULL;
    if ( !isatty( m_SerialFD ) )
    {
        close( m_SerialFD );
        m_SerialFD = -1;
        return false;
    }
    return true;
}

bool CMultiThreadSerial::SerialSet( DWORD m_nSpeed, BYTE m_nByteSize, BYTE m_nStopBits, BYTE m_nPairy )
{
    if ( !SetRaw( true ) )
    {
        close( m_SerialFD );
        m_SerialFD = -1;
        return false;
    }
    if ( !SetMin( 0 ) )
    {
        close( m_SerialFD );
        m_SerialFD = -1;
        return false;
    }
    if ( !SetTime( 0 ) )
    {
        close( m_SerialFD );
        m_SerialFD = -1;
        return false;
    }
    if ( !SetSpeed( m_nSpeed ) )
    {
        close( m_SerialFD );
        m_SerialFD = -1;
        return false;;
    }
    if ( !SetByteSize( m_nByteSize ) )
    {
        close( m_SerialFD );
        m_SerialFD = -1;
        return false;
    }
    if ( !SetStopBits( m_nStopBits ) )
    {
        close( m_SerialFD );
        m_SerialFD = -1;
        return false;
    }
    if ( !SetParity( m_nPairy ) )
    {
        close( m_SerialFD );
        m_SerialFD = -1;
        return false;
    }
    return true;
}

bool CMultiThreadSerial::SetRaw( bool isRaw )
{
    if ( !isatty( m_SerialFD ) ) return false;

    struct termios option;
    if ( tcgetattr( m_SerialFD, &option ) != 0) return false;
    if ( isRaw )
    {
        option.c_iflag &= ~(ICRNL|IGNCR|INLCR|IGNBRK|BRKINT);
        option.c_iflag &= ~(IXON|IXOFF|IXANY);
        option.c_oflag &= ~(OCRNL|OLCUC|ONLCR|OPOST);
        option.c_lflag &= ~(ICANON|ECHO|ECHOE|ISIG);
    }
    else
    {
        option.c_oflag |= OPOST;
        option.c_lflag |= (ICANON|ECHO|ECHOE|ISIG);
    }
    if ( tcsetattr( m_SerialFD, TCSANOW, &option ) != 0 ) return false;
    else return true;
}

bool CMultiThreadSerial::SetMin( UINT min )
{
    if ( !isatty( m_SerialFD ) ) return false;

    struct termios option;
    if ( tcgetattr( m_SerialFD, &option ) != 0) return false;
    option.c_cc[VMIN] = min;
    if ( tcsetattr( m_SerialFD, TCSANOW, &option ) != 0 ) return false;
    else return true;
}

bool CMultiThreadSerial::SetTime( UINT delay )
{
    if ( !isatty( m_SerialFD ) ) return false;

    struct termios option;
    if ( tcgetattr( m_SerialFD, &option ) != 0 ) return false;
    option.c_cc[VTIME] = delay;
    if ( tcsetattr( m_SerialFD, TCSANOW, &option ) != 0 ) return false;
    else return true;
}

bool CMultiThreadSerial::SetSpeed( DWORD speed )
{
    if ( !isatty( m_SerialFD ) ) return false;
    
    int i = 0;    
    int table_size = 23;
    int speed_table[] = { 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
                          1800, 2400, 4800, 9600, 19200, 38400, 57600, 115200, 230400, 460800,
                          500000, 576000, 921600 };
    int m_speed[] = { B0, B50, B75, B110, B134, B150, B200, B300, B600, B1200,
                      B1800, B2400, B4800, B9600, B19200, B38400, B57600, B115200, B230400, B460800,
                      B500000, B576000, B921600 };
    for ( i = 0; i < table_size; i++ ) {
        if ( speed_table[i] >= speed ) break;
    }
    struct termios option;
    if ( tcgetattr( m_SerialFD, &option ) != 0 ) return false;
    if ( cfsetispeed( &option, m_speed[i] ) != 0 ) return false;
    if ( cfsetospeed( &option, m_speed[i] ) != 0 ) return false;
    if ( tcsetattr( m_SerialFD, TCSANOW, &option ) != 0 ) return false;
    else return true;
}

bool CMultiThreadSerial::SetByteSize( BYTE bytesize )
{
    if ( !isatty( m_SerialFD ) ) return false;

    struct termios option;
    if ( tcgetattr( m_SerialFD, &option ) != 0 ) return false;
    option.c_cflag &= ~CSIZE;
    switch( bytesize )
    {
        case 5:
            option.c_cflag |= CS5;
            break;
        case 6:
            option.c_cflag |= CS6;
            break;
        case 7:
            option.c_cflag |= CS7;
            break;
        case 8:
            option.c_cflag |= CS8;
            break;
        default:
            option.c_cflag |= CS8;
            break;
    }
    if ( tcsetattr( m_SerialFD, TCSANOW, &option ) != 0 ) return false;
    else return true;
}

bool CMultiThreadSerial::SetStopBits( BYTE stopbits )
{
    if ( !isatty( m_SerialFD ) ) return false;

    struct termios option;
    if ( tcgetattr( m_SerialFD, &option ) != 0 ) return false;
    switch( stopbits )
    {
        case 1:
            option.c_cflag &= ~CSTOPB;
            break;
        case 2:
            option.c_cflag |= CSTOPB;
            break;
        default:
            option.c_cflag &= ~CSTOPB;
            break;
    }
    if ( tcsetattr( m_SerialFD, TCSANOW, &option ) != 0 ) return false;
    else return true;
}

bool CMultiThreadSerial::SetParity( BYTE parity )
{
    if ( !isatty( m_SerialFD ) ) return false;

    struct termios option;
    if ( tcgetattr( m_SerialFD, &option ) != 0 ) return false;
    switch( parity )
    {
        case NONE:
            option.c_cflag &= ~PARENB;
            option.c_iflag &= ~INPCK;
            break;
        case ODD:
            option.c_cflag |= PARENB;
            option.c_cflag |= PARODD;
            option.c_iflag |= INPCK;
            break;
        case EVEN:
            option.c_cflag |= PARENB;
            option.c_cflag &= ~PARODD;
            option.c_iflag |= INPCK;
        default:
            option.c_cflag &= ~PARENB;
            option.c_iflag &= ~INPCK;
            break;
    }
    if ( tcsetattr( m_SerialFD, TCSANOW, &option ) != 0 ) return false;
    else return true;
}