多线程监听串口

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <error.h>
#include <sys/types.h>  
#include <sys/stat.h> 
#include <fcntl.h>     
#include <termios.h>    
#include <sys/time.h>
#include <signal.h>
#include <string.h>
#include <poll.h>
#include <pthread.h>
#include <sys/select.h>  
#include <time.h> 


int speed_arr[] = {B115200, B38400, B19200, B9600, B4800, B2400, B1200, B300,
        B38400, B19200, B9600, B4800, B2400, B1200, B300, };
int name_arr[] = {115200, 38400,  19200,  9600,  4800,  2400,  1200,  300,
        38400,  19200,  9600, 4800, 2400, 1200,  300, };


int fd_uart1;
int fd_uart2;
int fd_uart3;
int fd_uart4;

#define UART1  "/dev/ttysWK0"
#define UART2  "/dev/ttysWK1"//"/dev/ttymxc1"
#define UART3  "/dev/ttysWK2"//"/dev/ttymxc2"
#define UART4  "/dev/ttysWK3"//"/dev/ttymxc3"
void delay(int i)
{
    int t,k;
    for(t=i;t>0;t--)
        for(k=50000;k>0;k--);
}

int init_serial(char *device,int speed)  
{  
    int serial_fd = 0,i; 
    serial_fd = open(device, O_RDWR | O_NOCTTY | O_NDELAY);  
    if (serial_fd < 0) {  
        perror("open");  
        return -1;  
    }  
      
    //串口主要设置结构体termios <termios.h>  
    struct termios options;  
      
    /**1. tcgetattr函数用于获取与终端相关的参数。 
    *参数fd为终端的文件描述符，返回的结果保存在termios结构体中 
    */  
    tcgetattr(serial_fd, &options);  
    /**2. 修改所获得的参数*/  
    options.c_cflag |= (CLOCAL | CREAD);//设置控制模式状态，本地连接，接收使能  
    options.c_cflag &= ~CSIZE;//字符长度，设置数据位之前一定要屏掉这个位  
    options.c_cflag &= ~CRTSCTS;//无硬件流控  
    options.c_cflag |= CS8;//8位数据长度  
    options.c_cflag &= ~CSTOPB;//1位停止位  
    options.c_iflag |= IGNPAR;//无奇偶检验位  
    options.c_oflag = 0; //输出模式  
    options.c_lflag = 0; //不激活终端模式  
    options.c_cc[VTIME] = 1; // 0.1seconds
    options.c_cc[VMIN] = 0;
    //cfsetospeed(&options, B115200);//设置波特率  
    for ( i= 0;  i < sizeof(speed_arr) / sizeof(int);  i++)
       {
               if  (speed == name_arr[i])
               {
                /*  设置串口的波特率 */
                cfsetispeed(&options, speed_arr[i]);
                cfsetospeed(&options, speed_arr[i]);
            }
       }  
    /**3. 设置新属性，TCSANOW：所有改变立即生效*/  
    tcflush(serial_fd, TCIFLUSH);//溢出数据可以接收，但不读  
    tcsetattr(serial_fd, TCSANOW, &options);  
    return serial_fd;  
}  
  
/** 
*串口发送数据 
*@fd:串口描述符 
*@data:待发送数据 
*@datalen:数据长度 
*/  
int uart_send(int fd, char *data, int datalen)  
{  
    int len = 0;  
    len = write(fd, data, datalen);//实际写入的长度  
    if(len == datalen) {  
        return len;  
    } else {  
        tcflush(fd, TCOFLUSH);//TCOFLUSH刷新写入的数据但不传送  
        return -1;  
    }  
      
    return 0;  
}  
  

int uart_recv2(int fd, char *data, int datalen)  
{  
    int len;
    len = read(fd, data, datalen);  
    //printf("len = %d
", len);  
    return len;  
} 

/*******************多线程************************/

char buf1[10];
char buf2[10];
char buf3[10];
char buf4[10];




void readuart1(void *vptr)
{
    int len;
    printf("uart1
");
    while(1){
        len =uart_recv2(fd_uart1,buf1,10);
        if(len>0)
            printf("uart1=%s
",buf1);
    }
}
void readuart2(void *vptr)
{
    int len;
    printf("uart2
");
    while(1){
        len =uart_recv2(fd_uart2,buf2,10);
        if(len>0)
            printf("uart2=%s
",buf2);
    }
}
void readuart3(void *vptr)
{
    int len;
    printf("uart3
");
    while(1){
        len =uart_recv2(fd_uart3,buf3,10);
        if(len>0)
            printf("uart3=%s
",buf3);
    }
}
void readuart4(void *vptr)
{
    int len;
    printf("uart4
");
    while(1){
        len =uart_recv2(fd_uart4,buf4,10);
        if(len>0)
            printf("uart4=%s
",buf4);
    }
}
void setTimer(int seconds, int useconds)  
{  
        struct timeval temp;  
  
        temp.tv_sec = seconds;  
        temp.tv_usec = useconds;  
  
        select(0, NULL, NULL, NULL, &temp);  
          
  
        return ;  
}  
  

void time_300ms(void *vptr)
{
    printf("timer start!
");
    while(1){
        setTimer(0, 300000); 
        printf("timer
");
    }
}

int main(int argc, char **argv)     
{  
       fd_uart1=init_serial(UART1,115200);
        delay(200);
     fd_uart2=init_serial(UART2,115200);
     delay(200);
     fd_uart3=init_serial(UART3,115200);
     delay(200);
     fd_uart4=init_serial(UART4,115200);
     delay(200);
    char buf[]="hello123456
";  
    
    memset(buf1,0,10);
    memset(buf2,0,10);
    memset(buf3,0,10);
    memset(buf4,0,10);
    
    uart_send(fd_uart1, buf, 10);
    usleep(50000);
    uart_send(fd_uart2, buf, 10); 
    usleep(50000);
    uart_send(fd_uart3, buf, 10);
    usleep(50000);
    uart_send(fd_uart4, buf, 10); 
    usleep(50000);
    pthread_t tid1,tid2,tid3,tid4,tid_timer;
    pthread_create(&tid1,NULL,&readuart1,NULL);
    pthread_create(&tid2,NULL,&readuart2,NULL);
    pthread_create(&tid3,NULL,&readuart3,NULL);
    pthread_create(&tid4,NULL,&readuart4,NULL);
    //pthread_create(&tid_timer,NULL,&time_300ms,NULL);
  while(1){
        sleep(1);
        //uart_send(fd_uart1, buf1, 10);
        //uart_send(fd_uart2, buf2, 10);
        //uart_send(fd_uart3, buf3, 10);
        //uart_send(fd_uart4, buf4, 10);
      }
      pthread_join(&tid1,NULL);
    pthread_join(&tid2,NULL);
    pthread_join(&tid3,NULL);
    pthread_join(&tid4,NULL);
    //pthread_join(&tid_timer,NULL);
    
    close(fd_uart1); 
    close(fd_uart2); 
    close(fd_uart3); 
    close(fd_uart4); 
    return 0;  
}

一个线程监听一路串口的收，可以在线程内使用select机制，减少IO操作