Linux C Serial串口编程

1,Linux 下打开串口设备，信号模型 读写程序

2,串口读写的IO复用Select模型

3, Linux 下打开串口设备，读写程序

1,Linux 下打开串口设备，信号模型 读写程序

[email protected]:/tmp/serial# cat main.c 
#include<stdio.h>  
#include<stdlib.h>  
#include<string.h>  
#include<unistd.h>  
#include<sys/types.h>  
#include<sys/stat.h>  
#include<fcntl.h>  
#include<termios.h>  
#include<errno.h>  

#define FALSE -1  
#define TRUE 0  

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

void set_speed(int fd, int speed)
{  
    int   i;   
    int   status;   
    struct termios   Opt;  
    tcgetattr(fd, &Opt);   
    for ( i= 0;  i < sizeof(speed_arr) / sizeof(int);  i++) 
    {   
        if  (speed == name_arr[i]) 
        {       
            tcflush(fd, TCIOFLUSH);       
            cfsetispeed(&Opt, speed_arr[i]);    
            cfsetospeed(&Opt, speed_arr[i]);     
            status = tcsetattr(fd, TCSANOW, &Opt);    
            if  (status != 0) 
            {          
                perror("tcsetattr fd1");    
                return;       
            }      
            tcflush(fd,TCIOFLUSH);     
        }    
    }  
}  

int set_Parity(int fd,int databits,int stopbits,int parity)  
{   
    struct termios options;   
    if  ( tcgetattr( fd,&options)  !=  0) 
    {   
        perror("SetupSerial 1");       
        return(FALSE);    
    }  
    options.c_cflag &= ~CSIZE;   
    switch (databits)   
    {     
        case 7:       
            options.c_cflag |= CS7;   
            break;  
        case 8:       
            options.c_cflag |= CS8;  
            break;     
        default:      
            fprintf(stderr,"Unsupported data size\n"); return (FALSE);    
    }  
    switch (parity)   
    {     
        case ‘n‘:  
        case ‘N‘:      
            options.c_cflag &= ~PARENB;   /* Clear parity enable */  
            options.c_iflag &= ~INPCK;     /* Enable parity checking */   
            break;    
        case ‘o‘:     
        case ‘O‘:       
            options.c_cflag |= (PARODD | PARENB);   
            options.c_iflag |= INPCK;             /* Disnable parity checking */   
            break;    
        case ‘e‘:    
        case ‘E‘:     
            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\n");      
            return (FALSE);    
    }    
    switch (stopbits)  
    {     
        case 1:      
            options.c_cflag &= ~CSTOPB;    
            break;    
        case 2:      
            options.c_cflag |= CSTOPB;    
            break;  
        default:      
            fprintf(stderr,"Unsupported stop bits\n");    
            return (FALSE);   
    }   
    /* Set input parity option */   
    if (parity != ‘n‘)     
        options.c_iflag |= INPCK;   
    tcflush(fd,TCIFLUSH);  
    options.c_cc[VTIME] = 150;   
    options.c_cc[VMIN] = 0; /* Update the options and do it NOW */  
    if (tcsetattr(fd,TCSANOW,&options) != 0)     
    {   
        perror("SetupSerial 3");     
        return (FALSE);    
    }   
    return (TRUE);    
}  

int main()  
{  
    int fd;  
    fd = open("/dev/ttyUSB0",O_RDWR);  
    if(fd == -1)  
    {  
        perror("serialport error\n");  
    }  
    else  
    {  
        printf("open ");  
        printf("%s",ttyname(fd));  
        printf(" succesfully\n");  
    }  

    set_speed(fd,115200);  
    if (set_Parity(fd,8,1,‘N‘) == FALSE)  {  
        printf("Set Parity Error\n");  
        exit (0);  
    }  
    char buf[] = "1234567890123456789012345678901234567890";
    int n= write(fd,buf,strlen(buf));  
    printf("字符串实际长度%zd \n", strlen(buf));
    printf("成功写入%d \n", n);
    char buff[512];   
    int nread;    
    while(1)  
    {  
        if((nread = read(fd, buff, 512))>0)  
        {  
            printf("Len: %d:",nread);  
            buff[nread] = ‘\0‘;  
            printf("%s \n",buff);  
        }  
    }  
    close(fd);  
    return 0;  
}
[email protected]:/tmp/serial# gcc -Wall main.c && ./a.out   
open /dev/ttyUSB0 succesfully
字符串实际长度40 
成功写入40 
Len: 32:12345678901234567890123456789012 
Len: 8:34567890 
^C
[email protected]:/tmp/serial#



2,串口读写的IO复用Select模型

[email protected]:/tmp/serial# cat main.c 
#include<stdio.h>  
#include<stdlib.h>  
#include<string.h>  
#include<unistd.h>  
#include<sys/types.h>  
#include<sys/stat.h>  
#include<sys/signal.h>  
#include<fcntl.h>  
#include<termios.h>  
#include<errno.h>  

#define FALSE -1  
#define TRUE 0  
#define flag 1  
#define noflag 0  

int wait_flag = noflag;  
int STOP = 0;  
int res;  

int speed_arr[] = { B38400, B19200, B9600, B4800, B2400, B1200, B300, B38400, B19200, B9600, B4800, B2400, B1200, B300, };  
int name_arr[] =  {  38400,  19200,  9600,  4800,  2400,  1200,  300,  38400,  19200,  9600,  4800,  2400,  1200,  300, };  
void set_speed (int fd, int speed)  
{  
    int i;  
    int status;  
    struct termios Opt;  
    tcgetattr (fd, &Opt);  
    for (i = 0; i < sizeof (speed_arr) / sizeof (int); i++)  
    {  
        if (speed == name_arr[i])  
        {  
            tcflush (fd, TCIOFLUSH);  
            cfsetispeed (&Opt, speed_arr[i]);  
            cfsetospeed (&Opt, speed_arr[i]);  
            status = tcsetattr (fd, TCSANOW, &Opt);  
            if (status != 0)  
            {  
                perror ("tcsetattr fd1");  
                return;  
            }  
            tcflush (fd, TCIOFLUSH);  
        }  
    }  
}  

int set_Parity (int fd, int databits, int stopbits, int parity)  
{  
    struct termios options;  
    if (tcgetattr (fd, &options) != 0)  
    {  
        perror ("SetupSerial 1");  
        return (FALSE);  
    }  
    options.c_cflag &= ~CSIZE;  
    switch (databits)  
    {  
        case 7:  
            options.c_cflag |= CS7;  
            break;  
        case 8:  
            options.c_cflag |= CS8;  
            break;  
        default:  
            fprintf (stderr, "Unsupported data size\n");  
            return (FALSE);  
    }  
    switch (parity)  
    {  
        case ‘n‘:  
        case ‘N‘:  
            options.c_cflag &= ~PARENB;   /* Clear parity enable */  
            options.c_iflag &= ~INPCK;    /* Enable parity checking */  
            break;  
        case ‘o‘:  
        case ‘O‘:  
            options.c_cflag |= (PARODD | PARENB);  
            options.c_iflag |= INPCK; /* Disnable parity checking */  
            break;  
        case ‘e‘:  
        case ‘E‘:  
            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\n");  
            return (FALSE);  
    }  

    switch (stopbits)  
    {  
        case 1:  
            options.c_cflag &= ~CSTOPB;  
            break;  
        case 2:  
            options.c_cflag |= CSTOPB;  
            break;  
        default:  
            fprintf (stderr, "Unsupported stop bits\n");  
            return (FALSE);  
    }  
    /* Set input parity option */  
    if (parity != ‘n‘)  
        options.c_iflag |= INPCK;  
    tcflush (fd, TCIFLUSH);  
    options.c_cc[VTIME] = 150;  
    options.c_cc[VMIN] = 0;   /* Update the options and do it NOW */  
    if (tcsetattr (fd, TCSANOW, &options) != 0)  
    {  
        perror ("SetupSerial 3");  
        return (FALSE);  
    }  
    return (TRUE);  
}  

void signal_handler_IO (int status)  
{  
    printf ("received SIGIO signale.\n");  
    wait_flag = noflag;  
}  

int main ()  
{  
    int fd;  
    struct sigaction saio;  
    fd = open ("/dev/ttyUSB0", O_RDWR);  
    if (fd == -1)  
    {  
        perror ("serialport error\n");  
    }  
    else  
    {  
        printf ("open ");  
        printf ("%s", ttyname (fd));  
        printf (" succesfully\n");  
    }  

    saio.sa_handler = signal_handler_IO;  
    sigemptyset (&saio.sa_mask);  
    saio.sa_flags = 0;  
    saio.sa_restorer = NULL;  
    sigaction (SIGIO, &saio, NULL);  

    //allow the process to receive SIGIO  
    fcntl (fd, F_SETOWN, getpid ());  
    //make the file descriptor asynchronous  
    fcntl (fd, F_SETFL, FASYNC);  

    set_speed (fd, 115200);  
    if (set_Parity (fd, 8, 1, ‘N‘) == FALSE)  
    {  
        printf ("Set Parity Error\n");  
        exit (0);  
    }  

    char str[] = "1234567890123456789012345678901234567890";
    int n= write(fd,str,strlen(str));  
    printf("字符串实际长度%zd \n", strlen(str));
    printf("成功写入%d \n", n);

    char buf[255];  
    while (STOP == 0)  
    {  
        usleep (100000);  
        /* after receving SIGIO ,wait_flag = FALSE,input is availabe and can be read */  
        if (wait_flag == 0)  
        {  
            memset (buf, 0, sizeof(buf));  
            res = read (fd, buf, 255);  
            printf ("nread=%d,%s\n", res, buf);  
            //    if (res ==1)  
            //      STOP = 1;       /*stop loop if only a CR was input */  
            wait_flag = flag; /*wait for new input */  
        }  
    }  

    close (fd);  
    return 0;  
}
[email protected]:/tmp/serial# gcc -Wall main.c && ./a.out   
open /dev/ttyUSB0 succesfully
字符串实际长度40 
成功写入40 
received SIGIO signale.
received SIGIO signale.
nread=32,12345678901234567890123456789012
received SIGIO signale.
nread=8,34567890
^C
[email protected]:/tmp/serial#


3, Linux 下打开串口设备，读写程序

[email protected]:/tmp/serial# cat main.c 
#include<stdio.h>  
#include<stdlib.h>  
#include<string.h>  
#include<unistd.h>  
#include<sys/types.h>  
#include<sys/stat.h>  
#include<sys/signal.h>  
#include<fcntl.h>  
#include<termios.h>  
#include<errno.h>  

#define FALSE -1  
#define TRUE 0  
#define flag 1  
#define noflag 0  

int wait_flag = noflag;  
int STOP = 0;  
int res;  

int speed_arr[] = { B38400, B19200, B9600, B4800, B2400, B1200, B300, B38400, B19200, B9600,  B4800, B2400, B1200, B300, };  
int name_arr[] =  { 38400, 19200, 9600, 4800, 2400, 1200, 300, 38400, 19200, 9600, 4800, 2400,  1200, 300, };  
void set_speed (int fd, int speed)  
{  
    int i;  
    int status;  
    struct termios Opt;  
    tcgetattr (fd, &Opt);  
    for (i = 0; i < sizeof (speed_arr) / sizeof (int); i++)  
    {  
        if (speed == name_arr[i])  
        {  
            tcflush (fd, TCIOFLUSH);  
            cfsetispeed (&Opt, speed_arr[i]);  
            cfsetospeed (&Opt, speed_arr[i]);  
            status = tcsetattr (fd, TCSANOW, &Opt);  
            if (status != 0)  
            {  
                perror ("tcsetattr fd1");  
                return;  
            }  
            tcflush (fd, TCIOFLUSH);  
        }  
    }  
}  

int set_Parity (int fd, int databits, int stopbits, int parity)  
{  
    struct termios options;  
    if (tcgetattr (fd, &options) != 0)  
    {  
        perror ("SetupSerial 1");  
        return (FALSE);  
    }  
    options.c_cflag &= ~CSIZE;  
    switch (databits)  
    {  
        case 7:  
            options.c_cflag |= CS7;  
            break;  
        case 8:  
            options.c_cflag |= CS8;  
            break;  
        default:  
            fprintf (stderr, "Unsupported data size\n");  
            return (FALSE);  
    }  
    switch (parity)  
    {  
        case ‘n‘:  
        case ‘N‘:  
            options.c_cflag &= ~PARENB;   /* Clear parity enable */  
            options.c_iflag &= ~INPCK;    /* Enable parity checking */  
            break;  
        case ‘o‘:  
        case ‘O‘:  
            options.c_cflag |= (PARODD | PARENB);  
            options.c_iflag |= INPCK; /* Disnable parity checking */  
            break;  
        case ‘e‘:  
        case ‘E‘:  
            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\n");  
            return (FALSE);  
    }  

    switch (stopbits)  
    {  
        case 1:  
            options.c_cflag &= ~CSTOPB;  
            break;  
        case 2:  
            options.c_cflag |= CSTOPB;  
            break;  
        default:  
            fprintf (stderr, "Unsupported stop bits\n");  
            return (FALSE);  
    }  
    /* Set input parity option */  
    if (parity != ‘n‘)  
        options.c_iflag |= INPCK;  
    tcflush (fd, TCIFLUSH);  
    options.c_cc[VTIME] = 150;  
    options.c_cc[VMIN] = 0;   /* Update the options and do it NOW */  
    if (tcsetattr (fd, TCSANOW, &options) != 0)  
    {  
        perror ("SetupSerial 3");  
        return (FALSE);  
    }  
    return (TRUE);  
}  

void signal_handler_IO (int status)  
{  
    printf ("received SIGIO signale.\n");  
    wait_flag = noflag;  
}  

int main ()  
{  
    int fd;  
    fd = open ("/dev/ttyUSB0", O_RDWR);  
    if (fd == -1)  
    {  
        perror ("serialport error\n");  
    }  
    else  
    {  
        printf ("open ");  
        printf ("%s", ttyname (fd));  
        printf (" succesfully\n");  
    }  

    set_speed (fd, 115200);  
    if (set_Parity (fd, 8, 1, ‘N‘) == FALSE)  
    {  
        printf ("Set Parity Error\n");  
        exit (0);  
    }  

    char str[] = "1234567890123456789012345678901234567890";
    int n= write(fd,str,strlen(str));  
    printf("字符串实际长度%zd \n", strlen(str));
    printf("成功写入%d \n", n);

    char buf[255];  
    fd_set rd;  
    int nread = 0;  
    while(1)  
    {  
        FD_ZERO(&rd);  
        FD_SET(fd, &rd);  
        while(FD_ISSET(fd, &rd))  
        {  
            if(select(fd+1, &rd, NULL,NULL,NULL) < 0)  
            {  
                perror("select error\n");  
            }  
            else  
            {  
                while((nread = read(fd, buf, sizeof(buf))) > 0)  
                {  
                    printf("nread= %02d,%s\n",nread, buf);  
                    memset(buf, 0 , sizeof(buf));  
                }  
            }  
        }  
    }  
    close (fd);  
    return 0;  
}
[email protected]:/tmp/serial# gcc -Wall main.c && ./a.out   
open /dev/ttyUSB0 succesfully
字符串实际长度40 
成功写入40 
nread= 32,12345678901234567890123456789012
nread= 08,34567890
时间： 2024-10-22 21:38:20

Linux C Serial串口编程的相关文章

Linux下的串口编程

打开串口 在Linux系统下,打开串口是通过使用标准的文件打开函数操作的. #include <fcntl.h> /* 以读写的方式打开 */ int fd = open( "/dev/ttyUSB0",O_RDWR); 设置串口 所有对串口的操作都是通过结构体 struct termios 和 几个函数实现的. tcgetattr //获取属性 tcsetattr //设置属性 cfgetispeed //得到输入速度 cfsetispeed //设置输入速度 cfget

Linux下串口编程【转】

本文转载自:http://blog.csdn.net/w282529350/article/details/7378388 /************声明:本人只是见到这篇文章对我帮助很大才转载的,但是这个完整的程序里面本来有语法错误的,现在让我改过来了************/ --------------------------------------------------------- Author             :tiger-johnWebSite            :b

android串口编程

最近在Android项目中要使用到串口编程,开始的时候为了省事,直接把以前在linux下用纯C写得串口程序封装成so库,再在JNI中调用so库,一点也没有问题. 虽说没有什么问题,总觉得在JAVA中使用纯C实现串口所有的操作很像是在“挂羊头卖狗肉”,而且也有点繁琐,想说JAVA应该把这些东西直接封装成API,于是在网上查资料,想找到类似于windows下的CreateFile的API接口,未果. 还好JAVA之中有个FileDescriptor类,可以把串口当作一个FileDescriptor,

linux下的串口通信

 /************声明:本人只是见到这篇文章对我帮助很大才转载的,但是这个完整的程序里面本来有语法错误的,现在让我改过来了************/ 今天的主角àUART0串口.因此对他的一切操作都和文件的操作一样(涉及到了open,read,write,close等文件的基本操作). 一．Linux下的串口编程又那几部分组成 1.    打开串口 2.    串口初始化 3.    读串口或写串口 4.    关闭串口 二．串口的打开 既然串口在linux中被看作了文件,那么在对文件

Linux 程序设计学习笔记----终端及串口编程基础之概念详解

转载请注明出处,谢谢! linux下的终端及串口的相关概念有: tty,控制台,虚拟终端,串口,console(控制台终端)详解 部分内容整理于网络. 终端/控制台 终端和控制台都不是个人电脑的概念,而是多人共用的小型中型大型计算机上的概念. 1.终端 一台主机,连很多终端,终端为主机提供了人机接口,每个人都通过终端使用主机的资源. 终端有字符哑终端和图形终端两种. 控制台是另一种人机接口, 不通过终端与主机相连, 而是通过显示卡-显示器和键盘接口分别与主机相连, 这是人控制主机的第一人机接口.

linux串口编程参数配置详解

1.linux串口编程需要的头文件 #include <stdio.h>         //标准输入输出定义 #include <stdlib.h>        //标准函数库定义 #include <unistd.h>       //Unix标准函数定义 #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h>          //文件控制定义 #incl

基于树莓派的Linux串口编程_实现自发自收

串口是计算机上一种非常通用设备通信的协议,常用PC机上包含的是RS232规格的串口,具有连接线少,通讯简单,得到广泛的使用. Linux对所有设备的访问是通过设备文件来进行的,串口也是这样,为了访问串口,只需打开其设备文件即可操作串口设备.在linux系统下面,每一个串口设备都有设备文件与其关联,设备文件位于系统的/dev目录下面.如linux下的/ttyS0,/ttyS1分别表示的是串口1和串口2. 树莓派UART端口的位置:见下图的GPIO14(TXD).GPIO 15(RXD) 本文是基于

linux串口编程参数配置详解(转)

1.linux串口编程需要的头文件 #include <stdio.h>         //标准输入输出定义#include <stdlib.h>        //标准函数库定义#include <unistd.h>       //Unix标准函数定义#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>          //文件控制定义#include &l

Linux 程序设计学习笔记----终端及串口编程及实例应用

转载请注明出处,http://blog.csdn.net/suool/article/details/38385355. 部分内容类源于网络. 终端属性详解及设置 属性 为了控制终端正常工作,终端的属性包括输入属性.输出属性.控制属性.本地属性.线路规程属性以及控制字符. 其在系统源代码的termios.h中定义(具体的说明文档http://pubs.opengroup.org/onlinepubs/7908799/xsh/termios.h.html),其结构体成员主要是 Thetermios