【驱动】串口驱动分析（四）-串口编程和调试方法

stty --help

Usage: stty [-F DEVICE] [--file=DEVICE] [SETTING]...
  or: stty [-F DEVICE] [--file=DEVICE] [-a|--all]
  or: stty [-F DEVICE] [--file=DEVICE] [-g|--save]
[选项]
-a, --all :   以容易阅读的方式打印当前的所有配置；
-g, --save: 以stty终端可读方式打印当前的所有配置。
-F, --file:   打印当前的所有设置打开指定的设备,并用此设备作为输入来代替标准输入
[参数]
终端设置：指定终端命令行的设置选项。  

stty -F /dev/ttyS0 speed 115200 cs8 -parenb -cstopb

stty -a -F /dev/ttyS0
speed 9600 baud; rows 0; columns 0; line = 0;
intr = ^C; quit = ^\; erase = ^?; kill = ^U; eof = ^D; eol = <undef>;
eol2 = <undef>; swtch = <undef>; start = ^Q; stop = ^S; susp = ^Z; rprnt = ^R;
werase = ^W; lnext = ^V; discard = ^O; min = 1; time = 0;
-parenb -parodd -cmspar cs8 hupcl -cstopb cread clocal -crtscts
-ignbrk -brkint -ignpar -parmrk -inpck -istrip -inlcr -igncr icrnl ixon -ixoff
-iuclc -ixany -imaxbel -iutf8
opost -olcuc -ocrnl onlcr -onocr -onlret -ofill -ofdel nl0 cr0 tab0 bs0 vt0 ff0
isig icanon iexten echo echoe echok -echonl -noflsh -xcase -tostop -echoprt
echoctl echoke -flusho -extproc

特殊字符：
  dsusp 字符   每当输入刷新时会发送一个用于终端阻塞信号的字符
   eof  字符    表示文件末尾而发送的字符(用于终止输入)
   eol  字符    为表示行尾而发送的字符
  eol2 字符    为表示行尾而发送的另一个可选字符
   erase 字符   擦除前一个输入文字的字符
   intr 字符    用于发送中断信号的字符
   kill 字符    用于擦除当前终端行的字符
  lnext 字符   用于输入下一个引用文字的字符
   quit 字符    用于发送退出信号的字符
  rprnt 字符   用于重绘当前行的字符
   start 字符   在停止后重新开启输出的字符
   stop 字符    停止输出的字符
   susp 字符    发送终端阻断信号的字符
  swtch 字符   在不同的shell 层次间切换的字符
  werase 字符  擦除前一个输入的单词的字符
 
特殊设置：
   N            设置输入输出速度为N 波特
  cols N       统治内核终端上有N 栏
  columns N    等于cols N
   ispeed N     设置输入速度为N 波特
  line N       设置行约束规则为N
   min N        和 -icanon 配合使用，设置每次一完整读入的最小字符数为<N>
   ospeed N     设置输出速度为N 波特
  rows N       向内核通告此终端有N 行
  size         根据内核信息输出当前终端的行数和列数
   speed        输出终端速度(单位为波特)
   time N       和-icanon 配合使用，设置读取超时为N 个十分之一秒
 
控制设置：
   [-]clocal    禁用调制解调器控制信号
   [-]cread     允许接收输入
  [-]crtscts   启用RTS/CTS 握手
   csN          设置字符大小为N 位，N 的范围为5 到8
   [-]cstopb    每个字符使用2 位停止位 (要恢复成1 位配合"-"即可)
   [-]hup       当最后一个进程关闭标准终端后发送挂起信号
   [-]hupcl     等于[-]hup
   [-]parenb    对输出生成奇偶校验位并等待输入的奇偶校验位
   [-]parodd    设置校验位为奇数 (配合"-"则为偶数)
 
输入设置：
   [-]brkint    任务中断会触发中断信号
   [-]icrnl     将回车转换为换行符
   [-]ignbrk    忽略中断字符
   [-]igncr     忽略回车
   [-]ignpar    忽略含有奇偶不对称错误的字符
  [-]imaxbel   发出终端响铃但不刷新字符的完整输入缓冲
   [-]inlcr     将换行符转换为回车
   [-]inpck     启用输入奇偶性校验
   [-]istrip    剥除输入字符的高8 位比特
  [-]iutf8     假定输入字符都是UTF-8 编码
  [-]iuclc     将大写字母转换为小写
  [-]ixany     使得任何字符都会重启输出，不仅仅是起始字符
   [-]ixoff     启用开始/停止字符传送
   [-]ixon      启用XON/XOFF 流控制
   [-]parmrk    标记奇偶校验错误 (结合255-0 字符序列)
   [-]tandem    等于[-]ixoff
 
输出设置：
  bsN          退格延迟的风格，N 的值为0 至1
  crN          回车延迟的风格，N 的值为0 至3
  ffN          换页延迟的风格，N 的值为0 至1
  nlN          换行延迟的风格，N 的值为0 至1
  [-]ocrnl     将回车转换为换行符
  [-]ofdel     使用删除字符代替空字符作填充
  [-]ofill     延迟时使用字符填充代替定时器同步
  [-]olcuc     转换小写字母为大写
  [-]onlcr     将换行符转换为回车
  [-]onlret    使得换行符的行为表现和回车相同
  [-]onocr     不在第一列输出回车
   [-]opost     后续进程输出
  tabN         水平制表符延迟的风格，N 的值为0 至3
  tabs         等于tab0
  -tabs        等于tab3
  vtN          垂直制表符延迟的风格，N 的值为0 至1
 
本地设置：
   [-]crterase  擦除字符回显为退格符
  crtkill      依照echoprt 和echoe 的设置清除所有行
  -crtkill     依照echoctl 和echol 的设置清除所有行
  [-]ctlecho   在头字符中输出控制符号("^c")
   [-]echo      回显输入字符
  [-]echoctl   等于[-]ctlecho
   [-]echoe     等于[-]crterase
   [-]echok     在每清除一个字符后输出一次换行
  [-]echoke    等于[-]crtkill 意义相同
   [-]echonl    即使没有回显任何其它字符也输出换行
  [-]echoprt   在"\"和"/"之间向后显示擦除的字符
   [-]icanon    启用erase、kill、werase 和rprnt 等特殊字符
   [-]iexten    允许POSIX 标准以外的特殊字符
   [-]isig      启用interrupt、quit和suspend 等特殊字符
   [-]noflsh    在interrupt 和 quit 特殊字符后禁止刷新
  [-]prterase  等于[-]echoprt
  [-]tostop    中止尝试向终端写入数据的后台任务
  [-]xcase     和icanon 配合使用，用转义符"\"退出大写状态
 
综合设置：
  [-]LCASE     等于[-]lcase
   cbreak       等于-icanon
   -cbreak      等于icanon
   cooked       等于brkint ignpar istrip icrnl ixon opost isig icanon eof eol 等的默认值
   -cooked      等于-raw
   crt          等于echoe echoctl echoke
   dec          等于echoe echoctl echoke -ixany intr ^c erase 0177 kill ^u
  [-]decctlq   等于[-]ixany
   ek           清除所有字符，将它们回溯为默认值
   evenp        等于parenb -parodd cs7
   -evenp       等于-parenb cs8
  [-]lcase     等于xcase iuclc olcuc
   litout       等于-parenb -istrip -opost cs8
   -litout      等于parenb istrip opost cs7
   nl           等于-icrnl -onlcr
   -nl          等于icrnl -inlcr -igncr onlcr -ocrnl -onlret
   oddp         等于parenb parodd cs7
   -oddp        等于-parenb cs8
   [-]parity    等于[-]evenp
   pass8        等于-parenb -istrip cs8
   -pass8       等于parenb istrip cs7
   raw          等于-ignbrk -brkint -ignpar -parmrk -inpck -istrip
                 -inlcr -igncr -icrnl -ixon -ixoff -iuclc -ixany
                 -imaxbel -opost -isig -icanon -xcase min 1 time 0
   -raw         等于cooked
   sane         等于cread -ignbrk brkint -inlcr -igncr icrnl -iutf8
                -ixoff -iuclc -ixany imaxbel opost -olcuc -ocrnl onlcr
                -onocr -onlret -ofill -ofdel nl0 cr0 tab0 bs0 vt0 ff0
                isig icanon iexten echo echoe echok -echonl -noflsh
                -xcase -tostop -echoprt echoctl echoke，
                所有特殊字符均使用默认值

fd = open("/dev/ttyUSB0",O_RDWR|O_NOCTTY|O_NDELAY);

close(fd)

read(fd,buff,8);
write(fd,buff,8);

struct termios {
  tcflag_t c_cflag    / 控制标志
  tcflag_t c_iflag;   / 输入标志
  tcflag_t c_oflag;   / 输出标志
  tcflag_t c_lflag;   / 本地标志
  tcflag_t c_cc[NCCS]; / 控制字符
}；

struct termios newtio,oldtio;
tcgetattr(fd,&oldtio);

newtio.c_cflag | = CLOCAL | CREAD;

cfsetispeed(&newtio,B115200);
cfsetospeed(&newtio,B115200);

newtio.c_cflag &= ~CSIZE;
newtio.c_cflag |= CS8;

newtio.c_cflag |= PARENB;
newtio.c_cflag |= PARODD;
newtio.c_iflag |= (INPCK | ISTRIP);
设置偶校验:
newtio.c_iflag |= (INPCK｜ISTRIP);
newtio.c_cflag |= PARENB;
newtio.c_cflag |= ~PARODD;

newtio.c_cflag &= ~CSTOPB;

newtio.c_cc[VTIME] = 0;
newtio.c_cc[VMIN] = 0;

int tcsetattr(int filedes,int opt,const struct termios termptr);

/@file      main.c
  @brief       串口应用编程测试
  @details
  @author      zhongyi  
  @date        2022-04-30
  @version     V1.0
 
 /

/ 包含的头文件 /
#include <stdio.h>        //标准输入输出,如printf、scanf以及文件操作
#include <stdlib.h>        //标准库头文件，定义了五种类型、一些宏和通用工具函数
#include <unistd.h>        //定义 read write close lseek 等Unix标准函数
#include <sys/types.h>    //定义数据类型，如 ssiz e_t off_t 等
#include <sys/stat.h>    //文件状态
#include <fcntl.h>        //文件控制定义
#include <termios.h>    //终端I/O
#include <errno.h>        //与全局变量 errno 相关的定义
#include <getopt.h>        //处理命令行参数
#include <string.h>        //字符串操作
#include <time.h>        //时间
#include <sys/select.h>    //select函数

#define DEV_NAME    "/dev/ttyS4"    ///< 串口设备


/@brief   设置串口参数：波特率，数据位，停止位和效验位
  @param[in]  fd         类型  int      打开的串口文件句柄
  @param[in]  nSpeed     类型  int     波特率
  @param[in]  nBits     类型  int     数据位   取值 为 7 或者8
  @param[in]  nParity     类型  int     停止位   取值为 1 或者2
  @param[in]  nStop      类型  int      效验类型 取值为N,E,O,,S
  @return     返回设置结果
  - 0         设置成功
  - -1     设置失败
 /
int setOpt(int fd, int nSpeed, int nBits, int nParity, int nStop)
{
    struct termios newtio, oldtio;

    // 保存测试现有串口参数设置，在这里如果串口号等出错，会有相关的出错信息
    if (tcgetattr(fd, &oldtio) != 0)
    {
        perror("SetupSerial 1");
        return -1;
    }

    bzero(&newtio, sizeof(newtio));        //新termios参数清零
    newtio.c_cflag |= CLOCAL | CREAD;    //CLOCAL--忽略 modem 控制线,本地连线, 不具数据机控制功能, CREAD--使能接收标志
    // 设置数据位数
    newtio.c_cflag &= ~CSIZE;    //清数据位标志
    switch (nBits)
    {
        case 7:
            newtio.c_cflag |= CS7;
        break;
        case 8:
            newtio.c_cflag |= CS8;
        break;
        default:
            fprintf(stderr, "Unsupported data size\n");
            return -1;
    }
    // 设置校验位
    switch (nParity)
    {
        case 'o':
        case 'O':                     //奇校验
            newtio.c_cflag |= PARENB;
            newtio.c_cflag |= PARODD;
            newtio.c_iflag |= (INPCK | ISTRIP);
            break;
        case 'e':
        case 'E':                     //偶校验
            newtio.c_iflag |= (INPCK | ISTRIP);
            newtio.c_cflag |= PARENB;
            newtio.c_cflag &= ~PARODD;
            break;
        case 'n':
        case 'N':                    //无校验
            newtio.c_cflag &= ~PARENB;
            break;
        default:
            fprintf(stderr, "Unsupported parity\n");
            return -1;
    }
    // 设置停止位
    switch (nStop)
    {
        case 1:
            newtio.c_cflag &= ~CSTOPB;
        break;
        case 2:
            newtio.c_cflag |= CSTOPB;
        break;
        default:
            fprintf(stderr,"Unsupported stop bits\n");
            return -1;
    }
    // 设置波特率 2400/4800/9600/19200/38400/57600/115200/230400
    switch (nSpeed)
    {
        case 2400:
            cfsetispeed(&newtio, B2400);
            cfsetospeed(&newtio, B2400);
            break;
        case 4800:
            cfsetispeed(&newtio, B4800);
            cfsetospeed(&newtio, B4800);
            break;
        case 9600:
            cfsetispeed(&newtio, B9600);
            cfsetospeed(&newtio, B9600);
            break;
        case 19200:
            cfsetispeed(&newtio, B19200);
            cfsetospeed(&newtio, B19200);
            break;
        case 38400:
            cfsetispeed(&newtio, B38400);
            cfsetospeed(&newtio, B38400);
            break;
        case 57600:
            cfsetispeed(&newtio, B57600);
            cfsetospeed(&newtio, B57600);
            break;
        case 115200:
            cfsetispeed(&newtio, B115200);
            cfsetospeed(&newtio, B115200);
            break;
        case 230400:
            cfsetispeed(&newtio, B230400);
            cfsetospeed(&newtio, B230400);
            break;
        default:
            printf("\tSorry, Unsupported baud rate, set default 9600!\n\n");
            cfsetispeed(&newtio, B9600);
            cfsetospeed(&newtio, B9600);
            break;
    }
    // 设置read读取最小字节数和超时时间
    newtio.c_cc[VTIME] = 1;     // 读取一个字符等待1(1/10)s
    newtio.c_cc[VMIN] = 1;        // 读取字符的最少个数为1

      tcflush(fd,TCIFLUSH);         //清空缓冲区
      if (tcsetattr(fd, TCSANOW, &newtio) != 0)    //激活新设置
      {
        perror("SetupSerial 3");
          return -1;
     }
      printf("Serial set done!\n");
    return 0;
}

/@brief 串口读取函数
  @param[in]  fd         打开的串口文件句柄
  @param[in]  rcv_buf 接收缓存指针
  @param[in]  data_len    要读取数据长度
  @param[in]  timeout     接收等待超时时间，单位ms
  @return     返回设置结果
  - >0      设置成功
  - 其他      读取超时或错误
 /
int UART_Recv(int fd, char rcv_buf, int data_len, int timeout)
{
    int len, fs_sel;
    fd_set fs_read;
    struct timeval time;

    time.tv_sec = timeout / 1000;              //set the rcv wait time
    time.tv_usec = timeout % 1000  1000;    //100000us = 0.1s

    FD_ZERO(&fs_read);        //每次循环都要清空集合，否则不能检测描述符变化
    FD_SET(fd, &fs_read);    //添加描述符

    // 超时等待读变化，>0：就绪描述字的正数目， -1：出错， 0 ：超时
    fs_sel = select(fd + 1, &fs_read, NULL, NULL, &time);
//    printf("fs_sel = %d\n", fs_sel);
    if(fs_sel)
    {
        len = read(fd, rcv_buf, data_len);
        return len;
    }
    else
    {
//        printf("Sorry,I am wrong!");
        return -1;
    }
}

/@brief 串口发送函数
  @param[in]  fd            打开的串口文件句柄
  @param[in]  send_buf     发送数据指针
  @param[in]  data_len     发送数据长度
  @return     返回结果
  - data_len    成功
  - -1            失败
 /
int UART_Send(int fd, char send_buf, int data_len)
{
    ssize_t ret = 0;

    ret = write(fd, send_buf, data_len);
    if (ret == data_len)
    {
        printf("send data is %s\n", send_buf);
        return ret;
    }
    else
    {
        printf("write device error\n");
        tcflush(fd,TCOFLUSH);
        return -1;
    }
}


/@fn main
  @brief main入口函数
 /
int main (int argc, char argv[])
{
    int fdSerial;

    // 打开串口设备
    fdSerial = open(DEV_NAME, O_RDWR | O_NOCTTY | O_NDELAY);
    if(fdSerial < 0)
    {
        perror(DEV_NAME);
        return -1;
    }
    // 设置串口阻塞， 0：阻塞， FNDELAY：非阻塞
    if (fcntl(fdSerial, F_SETFL, 0) < 0)    //阻塞，即使前面在open串口设备时设置的是非阻塞的
    {
        printf("fcntl failed!\n");
    }
    else
    {
        printf("fcntl=%d\n", fcntl(fdSerial, F_SETFL, 0));
    }
    if (isatty(fdSerial) == 0)
    {
        printf("standard input is not a terminal device\n");
        close(fdSerial);
        return -1;
    }
    else
    {
        printf("is a tty success!\n");
    }
    printf("fd-open=%d\n", fdSerial);


    // 设置串口参数
    if (setOpt(fdSerial, 115200, 8, 'N', 1)== -1)    //设置8位数据位、1位停止位、无校验
    {
        fprintf(stderr, "Set opt Error\n");
        close(fdSerial);
        exit(1);
    }

    tcflush(fdSerial, TCIOFLUSH);    //清掉串口缓存
    fcntl(fdSerial, F_SETFL, 0);    //串口阻塞


    char rcv_buf[100];
    int len;

    while(1)    //循环读取数据
    {
        len = UART_Recv(fdSerial, rcv_buf, 99, 10000);
        if(len > 0)
        {
            rcv_buf[len] = '\0';
            printf("receive data is %s\n", rcv_buf);
            printf("len = %d\n", len);
            UART_Send(fdSerial, rcv_buf, len);
        }
        else
        {
//            printf("cannot receive data\n");
        }
        usleep(100000);    //休眠100ms
    }
}