在現在的工控或者家用裝置通訊專案中，用到很多串列埠或者類串列埠通訊協議，其中 很多協議需要讀取操作，在讀取中為了防止阻塞，提高處理效能，縮短處理時間經常用到 select 函式來 讀取串列埠資料，select 是linux 真是個 神器啊，監控某一個檔案或者裝置，當有緩衝過來即可處理，而為了試用不同協議的長短不一，比如心跳包，和資料包，的處理不同，比較合適的做法就是按位讀取，當是心跳包的頭時，讀取接下來的心跳包，處理心跳。當是資料包的時候，讀取接下來的資料包，處理資料包。以下是串列埠讀取案例

介面函式 uart_raw.c:

//#include "uni_serial.h"
#include <stdio.h>
#include 
 
<stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>
#include <errno.h>
#include <limits.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <pthread.h>

//
 
extern int deal_with_uart_byteBybyte(char buffer);


/*
typedef struct node  
{  
    char p_send_buff[61];;  
    node* pNext;  
}Node;

Node* head = NULL;

//建立連結串列，頭結點data=0，pNext=NULL; 
 
bool createNodeList()  
{  
    head = (Node*) malloc(sizeof(Node));  
    if(NULL == head)  
    {  
        return false;  
    }  
    else  
    {  
        memset(head->p_send_buff,0,sizeof(char)*61);
        head->pNext = NULL;  
        return true;  
    }  
}  



Node* init_node(char *buff )
{
    Node* node = (Node*)malloc(sizeof(Node));
    int i=0;
    
    for(i=0;i<61;i++)
       head->p_send_buff[i]=buff[i];
    
    node->pNext = NULL;  
    return node2;
}


//增加節點  
bool addNode(Node* node)  
{  
    if(NULL == head)  
    {  
        return false;  
    }  
    
    Node* p = head->pNext;  
    Node* q = head;  
    while(NULL != p)  
    {  
        q = p;  
        p = p->pNext;  
    }  
    q->pNext = node;  
    node->pNext = NULL; 
    
    return true;      
}  


//遍歷節點
int num_node(Node* node)
{
    int num_n=0;
    if(NULL == head)  
    {  
        return 0;  
    }  
    Node* p = head->pNext;  
    //Node* q = head;
    
    while(NULL != p)  
    {  
        //q = p;  
        p = p->pNext;  
        num_n++;
    }  
    return num_n;
}



    
//刪除節點  
bool deleteNode(int index)  
{  
    if(NULL == head)  
    {  
        return false;  
    }  
    Node* p = head->pNext;  
      
    int length = 0;  
    while(NULL != p)  
    {  
        length ++;  
        p = p->pNext;  
    }  
  
    if(length < index)  
    {  
        return false;  
    }  
    else  
    {  
        Node* q = head;  
        p = head;  
        for(int i=0;i<index;i++)  
        {  
            q = p;  
            p = p->pNext;  
        }  
        Node* t = p->pNext;  
        q->pNext = t;  
        free(p);  
        return true;  
    }  
}  


int send_reoute()
{
    
    
    while(num_node(uart_node) > 5)
    {
        Node* p = head->pNext;  
        Node* q = head;
        //遍歷到最後一個節點 
        
        
        while(NULL != p)  
        {  
            //q = p;  
            p = p->pNext;  
        }
        
        // 傳送最後一個數據的 BUFF
        // 刪除最後一個 節點
        // 釋放最後一個節點 記憶體 指標
        // 長度 減少 
                
        

    }
    
    return 0;
}

 
*/











int deal_with_uart_byteBybyte(unsigned char buffer);


int uart_fd;
int uart_flag_ok=0;
struct termios options;
speed_t speed;

//speed=B2400;



unsigned char  BCC_CheckSum(unsigned char *buf, int len)
{
    unsigned char i;
    unsigned char checksum = 0;

    for(i = 0; i < len; i++) {
        checksum ^= *buf++;
    }
    return checksum;
} 



int uni_send_protocol(const unsigned char* buf, int n)
{
    //tcflush(uart_fd, TCIOFLUSH);
    int rc = 0;
    int i = 0;
    
    fprintf(stderr,"SEND serial>>>>>>>>>>>>>>>> ------------\n");
    for(i = 0; i < n; i++){
       
        printf("%02X ", buf[i]);
       
        
    }
    
    rc = write(uart_fd, buf, n);
    sync();
    usleep(5000);//5ms
    tcflush(uart_fd, TCIOFLUSH);
    return rc;
}






int set_speed() // 波特率 9600 
{
    int status;
    //struct termios opt;
    tcgetattr(uart_fd,&options);
    tcflush(uart_fd,TCIOFLUSH);
    //cfsetispeed(&options,speed);
    cfsetispeed(&options,B9600);
    
    status = tcsetattr(uart_fd,TCSANOW,&options);
    if(0 != status){
        perror("error: tcsetattr failed!");
        return -1;
    }

    tcflush(uart_fd,TCIOFLUSH);
    return 0;
}




int set_option()
{

    cfmakeraw(&options);/* 配置為原始模式 */
    options.c_cflag &= ~CSIZE;

    options.c_cflag |= CS8;
    //options.c_cflag &= ~PARENB;
    
    
    //opt.c_cflag |= CS8;
    
    //校驗位  偶校驗 
    options.c_cflag |= PARENB;
    
    
    options.c_cflag &= ~PARODD;
    options.c_iflag |= INPCK;
    
    //停止位
    options.c_cflag &= ~CSTOPB;
    
    /*設定等待時間和最小接收字元*/
    options.c_cc[VTIME] = 0;
    options.c_cc[VMIN] = 1;

    return 1;
}



int set_parity()
{

    if (tcgetattr(uart_fd,&options)!=0) {
        perror("error set_parity:tcgetattr.");
        return -1;
    }

    set_option();

    if (tcsetattr(uart_fd,TCSANOW,&options) != 0) {
        perror("error set_parity:tcsetattr");
        return -1;
    }

    tcflush(uart_fd,TCIOFLUSH);
    return 0;
}


int uni_InitUart()
{
    const char device[] = "/dev/ttyS2"; 
    int flags = O_RDWR | O_NOCTTY | O_NDELAY |O_SYNC;

    uart_fd = open(device, flags );
    if(-1 == uart_fd){
        printf("open %s failed\n", device);
        return -1;
    }

    set_speed();
    if (set_parity() < 0){
        printf("set parity error !\n");
        return -1;
    }

    return uart_fd;
}


int Uart_receive_callBack(char p, int (*ptr)()) 
{
    (*ptr)(p);
}




void* run_uart_receive_pid()
{
    int rc;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       char buffer;
    unsigned char buffer1;
    fd_set rfds;
    struct timeval tv;
    int retval;
    int ret;

    while(1)
    {
        FD_ZERO(&rfds);
        FD_SET(uart_fd, &rfds);

        tv.tv_sec = 1;
        tv.tv_usec = 1000;
        retval = select(uart_fd + 1, &rfds, NULL, NULL, &tv);
        
        //fprintf(stderr,"select!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");

        if (retval < 0)
            perror("select()");
        else if (retval)
        {
            if(FD_ISSET(uart_fd, &rfds) )
            {
                rc = read(uart_fd, &buffer, 1);
                if(rc >= 0){
                    //printf("%02X ", buffer);
                }
                Uart_receive_callBack(buffer, deal_with_uart_byteBybyte);// 讀取一個處理一個 
                buffer=0x00;
                uart_flag_ok=1;
            }
        }else{
            //return 1;
            //printf("No data within few times.\n");
        }

    //printf("get out a serial data!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
    //tcflush(uart_fd, TCIOFLUSH);
    }
}


int uni_InitUart_recv_pthread()
{
    pthread_t uart_receive_pid;

    int ret = pthread_create(&uart_receive_pid,  NULL, &run_uart_receive_pid, NULL);
    if (ret != 0)
    {
        fprintf(stderr,"%s","uni_receive_serial pthread_create fail!\n");
        return ret;
    }
}



int uni_recv_protocol(unsigned char* buf, int n)
{
    int rc, i;
    int count = 0;
    fprintf(stderr,"GET serial<<<<<<<<<<<<< ------------\n");
    for(i = 0; i < n; i++){
        rc = read(uart_fd, &buf[i], 1);
        printf("%02X ", buf[i]);
        if(rc <= 0){
            return rc;
        }
        count++;
    }

    tcflush(uart_fd, TCIOFLUSH);
    return count;
}





void uni_release_serial()
{
    close(uart_fd);
}

主函式呼叫例項函式：

處理函式最好做成回撥函式，在引用檔案中直接用 extern 來註明外部函式即可。

extern int deal_with_uart_byteBybyte(char buffer);

int i_uart_index;
int length_uart;

char buffer_command[16];
char old_command[16];







int deal_with_uart_byteBybyte(char buffer)
{
    int i ;
    int count_sum = 0;
    //printf("%02X \n", buffer);

    if(i_uart_index == 0){ //判斷第一個位 
        if(buffer == 0xf1){// 主機心跳包 
            length_uart = 1;
            buffer_command[0] = buffer; //buff == 0xf1 
            i_uart_index++;
        }else if(buffer == 0x11){//主機資料幀 
            buffer_command[0] = buffer;
            i_uart_index++;
        }
    }else if(i_uart_index == 1){ //判斷第二個位數 
        if(buffer_command[0] == 0xf1){
            if(buffer == 0x7a){
                printf("get a heart beat message !!!!!!!!!!!!!!!!\n");
                //printf("send >>>>>>>>>>\n");
                char buff_heart[2]={0};
                buff_heart[0]=0XF9;
                buff_heart[1]=0X7A;
                //char buff_heart[8]={0XBB,0X00,0X01,0X04,0X02,0X01,0X00,0XBD};
                if(uni_send_protocol(buff_heart,2) < 0)
                {
                    printf("write ERROR!\n");
                    return 0;
                }
                i_uart_index = 0;
            }
        }else if(buffer_command[0] == 0x11){
            length_uart = buffer - 0x00;
            buffer_command[1] = buffer;
            i_uart_index++;
        }
    }else{ //判斷之後的位數  
        if((length_uart+3) > i_uart_index && 16 > i_uart_index){
            buffer_command[i_uart_index] = buffer;
            i_uart_index++;
        }else if ((length_uart+3) == i_uart_index){
            printf("get a data message !!!!!!!!!!!!!!!!\n");
            for(i =0; i < i_uart_index; i++){
                printf("%02X \n", buffer_command[i]);
                //old_command[i]=buffer_command[i];//複製到 old_buff  
            }
            
            for(i =0; i < i_uart_index-1; i++){
                count_sum += buffer_command[i] - 0x00;
            }

            if((count_sum % 256) == buffer_command[i_uart_index -1]){
                printf("data command check OK!!!!!!!!!!!!!!!!\n");
                //int i=0;
                
                
                
                //TODO deal with command message
                /*
                char buff_heart[8]={0XBB,0X00,0X01,0X04,0X02,0X01,0X00,0XBD};
                if(uni_send_protocol(buff_heart,8) < 0)
                {
                    printf("write ERROR!\n");
                    return 0;
                }*/
                
                //第一次
                
                if(recved_times==1)
                {
                    for(i =0; i < i_uart_index; i++){
                        old_command[i]=buffer_command[i];  
                    }
                    recved_times=0;//清零 只同步一次 
                }
                else{
                    deal_uart_buff(buffer_command,old_command,i_uart_index);
                    
                    for(i =0; i < i_uart_index; i++){
                        old_command[i]=buffer_command[i];  
                    }
                }
                
                i_uart_index = 0;
            }else{
                printf("data command check fail!!!!!!!!!!!!!!!!\n");
                i_uart_index = 0;
            }
        }else{
            i_uart_index = 0;
        }
    
    }
}




int main()
{
    
    uni_InitUart();
    uni_InitUart_recv_pthread();
    return 0;
}