Linux串口编程

串口编程     

       串口在Linux中也是一个设备文件（一切皆文件），这一部分从裸机开发转变过来还需要一定时间适应，不过可以去看看野火的Linux教程，中关于使用shell操作串口的示例有一个宏观的的体验和认知。回到通过程序使用串口收发数据，其也就如同读写一个普通文件一般，一般步骤是

1、打开串口设备（字符设备）（open系统调用）。

2、配置串口。

3、然后就是如同读写文件一样使用，read和write函数进程数据的收发了。

4、最后就是使用完后的关闭close操作。

第一步打开字符设备通过调用open，这个过程和打开一个普通文件可能的唯一区别可能就是需要加上O_NOCTTY选项实际测试不加上好像也不会因为接收到0x03而导致程序退出(Ctrl+c == ascii(0x03))。

然后就是配置串口的约定参数如struct termios

  {
    tcflag_t c_iflag;        /* input mode flags */
    tcflag_t c_oflag;        /* output mode flags */
    tcflag_t c_cflag;        /* control mode flags */
    tcflag_t c_lflag;        /* local mode flags */
    cc_t c_line;            /* line discipline */
    cc_t c_cc[NCCS];        /* control characters */
    speed_t c_ispeed;        /* input speed 
    speed_t c_ospeed;        /* output speed */
  };

 

1.1 c_iflag 输入设置

负责控制串口输入数据的处理配置。

 

标志	作用	标志	作用
IGNPAR	忽略桢错误和奇偶校验	IGNBRK	忽略 BREAK 条件
INPCK	打开输入奇偶校验	PARMRK	标记奇偶错，只有设置INPCK并且没有设置 IGNPAR 才有效
ISTRIP	去掉字符第8位	IGNCR	忽略输入中的回车CR
ICRNL	将输入的CR转换为 NL，除非设了IGNCR	INLCR	将输入的NL(换行)转换为CR
IXON	启用输出的 XON/XOFF 流控制	IXOFF	启用输入的 XON/XOFF 流控制
IXANY	尝试任何字符可做重启输出信号，默认只能START字符恢复输出	IUCLC	（no posix）将输入中的大写字母映射为小写字母
BRKINIT	如果IGNBRK没有设置当这是一个控制终端时将发送SIGINT信号	IUTF8	（no posix）输入是utf8字符允许在cooked 模式下正确进行字符擦除
IMAXBEL	（no posix）输入队列满时提示（ring bell）

 

使用软件流控制是启用 IXON、IXOFF 和 IXANY 选项：
opt.c_iflag |= (IXON | IXOFF | IXANY);
相反，要禁用软件流控制是禁止上面的选项：
opt.c_iflag &= ~(IXON | IXOFF | IXANY);

除此之外还有一个更粗暴的方式就是

opt.c_iflag = 0；

opt.c_iflag |= IXOFF;

1.2 c_oflag 输出设置

负责控制串口输出数据的处理配置。

标志	作用	标志	作用
OPOST	执行输出处理	OFILL	对于延迟使用填充符
ONLCR	将NL转换为CR-NL	OCRNL	将输出的CR转换为NL
ONLRET	不输出CR回车	ONOCR	在0列(行首)不输出CR
OFDEL	填充符为DEL，否则为 NULL	OLCUC	将输出的小写字符转换为大写字符
XTABS	将制表符扩充为空格	BSDLY	退格延迟屏蔽
CRDLY	CR 延迟屏蔽	CMSPAR	标志或空奇偶性
FFDLY	换页延迟屏蔽	NLDLY	新行延迟屏蔽

启用输出处理
启用输出处理需要在 c_oflag 成员中启用 OPOST 选项，其操作方法如下：

options.c_oflag |= OPOST;

使用原始输出
就是禁用输出处理，使数据能不经过处理、过滤地完整地输出到串口。
当 OPOST 被禁止，c_oflag 其它选项也被忽略，其操作方法如下：

options.c_oflag &= ~OPOST;

 

1.3 c_cflag 控制选项

可设置串口的波特率、数据位、奇偶校验、停止位以及硬件流控制。

标志	作用	标志	作用
CSIZE	数据位屏蔽	CS7	7位数据
CS5	5位数据	CS8	8位数据
CS6	6位数据	CLOCAL	忽略modem控制线
PARENB	校验使能	PARODD	寄校验使能，否则是偶校验
CSTOPB	两位停止位，否则为1位	CREAD	打开接收
CRTSCTS	硬件流控（ no posix）

比如关闭硬件流控，115200波特率，8位数据位，1位停止，偶校验配置如下：

    //设置串口输出波特率
    cfsetospeed(&opt, B115200);
    //设置串口输入波特率
    cfsetispeed(&opt, B115200);
    //设置数据位数
    opt.c_cflag &= ~CSIZE;
    opt.c_cflag |= CS8;
    //偶校验位
    opt.c_cflag |= PARENB;
    opt.c_cflag &= ~PARODD;
    //设置停止位 1bit
    opt.c_cflag &= ~CSTOPB;
    //激活本地连接和接受使能选项
    opt.c_cflag |= CLOCAL | CREAD;

1.3 c_lflag 控制选项

控制串口驱动怎样控制输入字符。

标志	作用	标志	作用
ISIG	使能特殊字符的信号发送	NOFLSH	在中断或退出键后禁用刷清
ICANON	启用规范输入，默认开启	IEXTEN	启用扩充的输入字符处理
XCASE		ECHOCTL	如果设置了 ECHO，除了 TAB, NL, START, 和 STOP 之外的 ASCII 控制信号被回显为^X字符形式,
ECHOPRT		ECHO	回送输入关闭
ECHOE	如果设置了 ICANON，字符 ERASE 擦除前一个输入字符，WERASE 擦除前一个词	ECHONL	如果设置了 ICANON，回送NL
ECHOK	如果设置了 ICANON，字符KILL删除当前行。	ECHOKE	如果设置了 ICANON，回显 KILL 时将删除一行中的每个字符，如同指定了 ECHOE 和 ECHOPRT 一样
PENDIN		TOSTOP	对于后台输出发送SIGTTOU信号

经典输入
经典输入是以面向行设计的。输入字符会被放入一个缓冲之中，这样可以与用户以交互的方式编辑缓冲的内容，直到收到CR(carriage return)或者LF(line feed)字符。

options.c_lflag |= (ICANON | ECHO | ECHOE);

原始输入
输入字符只是被原封不动的接收。一般情况中，如果要使用原始输入模式，程序中需要去掉ICANON，ECHO，ECHOE和ISIG选项：

options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG)；

1.4 c_cc[NCCS] 控制字符

主要用于控制串口在收到指定字符设备时的处理方式，如果设置对应的控制字符为1，则特殊字符的特殊功能将启用，比如

//当ISIG设置时收到Ctrl+c（或0x0177）是认为这是一个中断，将发送SIGINT信号
options.c_cc[VINTR] = 1;

其中VMIN和VTIME是比较特殊的两个控制字符

当 MIN > 0，TIME > 0 时

计时器在收到第一个字节后启动， 在计时器超时之前 （TIME 的时间到） ， 若已收到 MIN个字节，则 read 返回 MIN 个字节，否则，在计时器超时后返回实际接收到的字节。

注意：因为只有在接收到第一个字节时才开始计时，所以至少可以返回 1 个字节。这种情形中，在接到第一个字节之前，调用者阻塞。如果在调用 read 时数据已经可用，则如同在 read 后数据立即被接到一样。

当 MIN > 0，TIME = 0 时

MIN 个字节完整接收后，read 才返回，这可能会造成 read 无限期地阻塞。

当 MIN = 0, TIME > 0 时

TIME 为允许等待的最大时间，计时器在调用 read 时立即启动，在串口接到 1 字节数据或者计时器超时后即返回，如果是计时器超时，则返回 0。

当 MIN = 0，TIME = 0 时

如果有数据可用，则 read 最多返回所要求的字节数，如果无数据可用，则 read 立即返回 0。

     如果只使用四线串口，需要关闭流控，否则可能会出现无法接收数据的问题。其次是几个标志位的名字很像，千万不要不把另一个的标志位的宏赋值到另一个标志位上这样牛头不对马嘴的还不容易发现问题。

参考代码：

/**
  * @brief  初始化串口
  * @param  device 设备
  * @retval -1 失败
  *           0 ok
  */
int init_serial(char *device)
{
    struct termios opt;
    int uart_fd;
    uart_fd = open(device,O_RDWR|O_NOCTTY);
    if(uart_fd<0){
        printf("The %s device open failed.\n",device);
        return -1;
    }
    #if 1
    //fcntl(uart_fd, F_SETFL, FNDELAY);
    //清空串口接收缓冲区
    tcflush(uart_fd, TCIOFLUSH);
    // 获取串口参数 opt
    tcgetattr(uart_fd, &opt);
    //设置串口输出波特率
    cfsetospeed(&opt, B115200);
    //设置串口输入波特率
    cfsetispeed(&opt, B115200);
    //设置数据位数
    opt.c_cflag &= ~CSIZE;
    opt.c_cflag |= CS8;
    //偶校验位
    opt.c_cflag |= PARENB;
    opt.c_cflag &= ~PARODD;
    //设置停止位 1bit
    opt.c_cflag &= ~CSTOPB;
    //激活本地连接和接受使能选项
    opt.c_cflag |= CLOCAL | CREAD;
    //关闭流控 接收回车符
    //opt.c_cflag &= ~IGNCR;
    //opt.c_cflag |= IXOFF;
    //原始数据输出
    opt.c_oflag &= (~ONLCR);
    opt.c_oflag &= (~OCRNL);
    //关闭echo
    opt.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
    //输入关闭流控 接收回车符
    opt.c_iflag |= IXOFF;
    opt.c_iflag &= (0|IXOFF);
    #endif
    //更新配置
    while(1)
    {
        errno = 0;
        if(tcsetattr(uart_fd, TCSANOW, &opt) != 0)
        {
            if(errno == EINTR)
            {
                continue;
            }
            #ifdef PRINTF_MSG
            else if(errno == EINVAL)
            {
                printf("config para elligal\n");
            }
            else if((errno == ENOTTY )||(errno == EBADF))
            {
                printf("fd error\n");
            }
            else
            {
                printf("Device %s is set Fail%d\n");
            }
            #endif
            return -1;
        }
        break;
    }
    #ifdef PRINTF_MSG
    printf("Device %s is set to 115200bps,8bits data , 1bit stop\n",device);
    #endif
    return uart_fd;
}
/**
  * @brief  读取串口数据
  * @param  buff 数据帧
  * @retval  数据长度
  *
  */
int recv_data_from_serial(int uart_fd,char *buf)
{
    int ret,len=0,data_len;
    struct  pollfd fds[1];
    fds[0].fd = uart_fd;
    fds[0].events = POLLIN;
    while(1)
    {
        ret = poll(fds,1,0);
        #ifdef PRINTF_MSG
        //perror("uart poll");
        #endif /*PRINTF_MSG*/
        if(ret < 0)
        {
            /*调用出错*/
            if(errno == EINTR)
            {
                /* 系统调用出错，可重试 */
                continue;
            }
            else
            {
                /* 系统调用出错，致命错误 */
                #ifdef PRINTF_MSG
                printf("uart read fail exit\n");
                #endif /*PRINTF_MSG*/
                exit(-1);
            }

        }
        else if(ret >= 1)
        {
            /*有数据可读*/
            if(fds[0].revents & (POLLIN|POLLPRI))
            {
                if(ioctl(uart_fd,FIONREAD,&data_len)<0)
                {
                    /* retry */
                    continue;
                }
                ret = read(uart_fd,buf,data_len);
                if(ret <= 0)
                {
                    /*读失败*/
                }
                else if(ret)
                {
                    len += ret;
                    buf += ret;
                }
            }
        }
        else
        {
            /* no data to read */
            break;
        }

    }
    return len;
}
/**
  * @brief  通过串口发送数据
  * @param  uart_fd 串口描述符
  * @param  data 数据帧
  * @param  lenth 数据长度
  * @retval 1 数据长度非法
  *           0 ok
  */
int send_data_from_serial(int uart_fd,char *data,int lenth)
{
    int ret,len=0;
    struct  pollfd fds;
    fds.fd = uart_fd;
    fds.events = POLLOUT;
    while(1)
    {
        ret = poll(&fds,1,0);
        if(ret < 0)
        {
            /*调用出错*/
            if(errno == EINTR)
            {
                /* 系统调用出错，可重试 */
                continue;
            }
            else
            {
                /* 系统调用出错，致命错误 */
                #ifdef PRINTF_MSG
                printf("uart write fail exit\n");
                #endif /*PRINTF_MSG*/
                exit(-1);
            }
        }
        else if(ret == 1)
        {
            /*可写*/
            if(fds.revents & POLLOUT)
            {
                ret = write(uart_fd,data+len,lenth);
                if(ret < 0)
                {
                    /*写失败*/
                }
                else if(ret > 0)
                {
                    len+=ret;
                    /*写完了*/
                    if(len == lenth)
                    {

                        break;
                    }
                }
            }
        }
        else
        {
            /* 退出 */
            break;
        }
    }
    return len;
}

int deinit_serial(int uart_fd)
{
    close(uart_fd);
    return 0;
}