串口编程-termios编程

linux使用terminfo数据库来描述终端能力以及调用对应功能的方法。

termios简述

POSIX定义了完成终端I/O的标准方法：termios函数族

#include <termios.h>
#include <unistd.h>

struct termios {
    tcflag_t c_iflag;
    tcflag_t c_oflag;
    tcflag_t c_cflag;  /*control modes*/
    tcflag_t c_lflag;  /*local modes*/
    cc_t c_cc[NCCS];   /*control chars*/
};

termios, tcgetattr, tcsetattr, tcsendbreak, tcdrain, tcflush, tcflow,
cfmakeraw, cfgetospeed, cfgetispeed, cfsetispeed, cfsetospeed
- 获取和设置终端属性，行控制，获取和设置波特率

#include <termios.h>
#include <unistd.h>
int tcgetattr(int fd, struct termios *termios_p);
int tcsetattr(int fd, int optional_actions, struct termios *termios_p);
int tcsendbreak(int fd, int duration);
int tcdrain(int fd);
int tcflush(int fd, int queue_selector);
int tcflow(int fd, int action);
int cfmakeraw(struct termios *termios_p);
speed_t cfgetispeed(struct termios *termios_p);
speed_t cfgetospeed(struct termios *termios_p);
int cfsetispeed(struct termios *termios_p, speed_t speed);
int cfsetospeed(struct termios *termios_p, speed_t speed); 

RETURN VALUE 返回值

cfgetispeed() 返回 termios 结构中存储的输入波特率。

cfgetospeed() 返回 termios 结构中存储的输出波特率。

其他函数返回：
0
成功
-1
失败，并且为 errno 置值来指示错误。
1. 获取和设置终端属性
int tcgetattr(int fd, struct termios *termios_p);
int tcsetattr(int fd, int optional_actions, struct termios *termios_p);
其中optional_actions决定什么时候起作用，可取如下值
TCSANOW：不等数据传输完毕就立即改变属性。
TCSADRAIN：等待所有数据传输结束才改变属性。
TCSAFLUSH：清空输入输出缓冲区才改变属性。
注意：当进行多重修改时，应当在这个函数之后再次调用 tcgetattr() 来检测是否所有修改都成功实现。
2.波特率函数
获取波特率
speed_t cfgetospeed(struct termios *termios_p);
speed_t cfgetispeed(struct termios *termios_p);
设置波特率
int cfsetospeed(struct termios *termios_p, speed_t speed);
int cfsetispeed(struct termios *termios_p, speed_t speed);
取值必须是以下常量之一：
        B0
        B50
        B75
        B110
        B134
        B150
        B200
        B300
        B600
        B1200
        B1800
        B2400
        B4800
        B9600
        B19200
        B38400
        B57600
        B115200
        B230400
零值 B0 用来中断连接。如果指定了 B0，不应当再假定存在连接。通常，这样将断开连接。CBAUDEX 是一个掩码，指示高于 POSIX.1 定义的速度的那一些 (57600 及以上)。因此，B57600 & CBAUDEX 为非零。
3.线路控制函数
int tcdrain (int fd);    //等待所有写入fd中的数据输出
int tcflush (int fd, int queue_selector);    
//丢弃要写入fd，但尚未传输的数据，或者收到但是尚未读取的数据。
取决于queue_selector 的值：

    TCIFLUSH 
    刷新收到的数据但是不读 
    TCOFLUSH 
    刷新写入的数据但是不传送 
    TCIOFLUSH 
    同时刷新收到的数据但是不读，并且刷新写入的数据但是不传送 

int tcflow (int fd, int action);    //挂起 fd 上的数据传输或接收。
取决于 action 的值：

    TCOOFF 
    挂起输出 
    TCOON 
    重新开始被挂起的输出 
    TCIOFF 
    发送一个 STOP 字符，停止终端设备向系统传送数据 
    TCION 
    发送一个 START 字符，使终端设备向系统传输数据 

打开一个终端设备时的默认设置是输入和输出都没有挂起。
int tcsendbreak (int fd, int duration);    //传送连续的 0 值比特流，持续一段时间，如果终端使用异步串行数据传输的话。
如果 duration 是 0，它至少传输 0.25 秒，不会超过 0.5 秒。如果 duration 非零，它发送的时间长度由实现定义。
如果终端并非使用异步串行数据传输，tcsendbreak() 什么都不做。
4、成员的值
（1）c_iflag 标志常量：
Input mode ( 输入模式)
input mode可以在输入值传给程序之前控制其处理的方式。
其中输入值可能是由序列埠或键盘的终端驱动程序所接收到的字元。
我们可以利用termios结构的c_iflag的标志来加以控制，其定义的方式皆以OR来加以组合。
        IGNBRK ：忽略输入中的 BREAK 状态。 （忽略命令行中的中断）
        BRKINT ：（命令行出现中断时，可产生一插断）如果设置了 IGNBRK，将忽略 BREAK。如果没有设置，但是设置了 BRKINT，那么 BREAK 将使得输入和输出队列被刷新，如果终端是一个前台进程组的控制终端，这个进程组中所有进程将收到 SIGINT 信号。如果既未设置 IGNBRK 也未设置 BRKINT，BREAK 将视为与 NUL 字符同义，除非设置了 PARMRK，这种情况下它被视为序列 377 � �。
        IGNPAR ：忽略桢错误和奇偶校验错。
        PARMRK ：如果没有设置 IGNPAR，在有奇偶校验错或桢错误的字符前插入 377 �。如果既没有设置 IGNPAR 也没有设置 PARMRK，将有奇偶校验错或桢错误的字符视为 �。 

        INPCK ：启用输入奇偶检测。
        ISTRIP ：去掉第八位。
        INLCR :将输入中的 NL 翻译为 CR。（将收到的换行符号转换为Return）
        IGNCR :忽略输入中的回车。
        ICRNL :将输入中的回车翻译为新行 (除非设置了 IGNCR)(否则当输入信号有 CR 时不会终止输入)。
        IUCLC :(不属于 POSIX) 将输入中的大写字母映射为小写字母。
        IXON :启用输出的 XON/XOFF 流控制。  
        IXANY :(不属于 POSIX.1；XSI) 允许任何字符来重新开始输出。(?)
        IXOFF :启用输入的 XON/XOFF 流控制。
        IMAXBEL:(不属于 POSIX) 当输入队列满时响零。Linux 没有实现这一位，总是将它视为已设置。
（2）c_oflag 标志常量：Output mode ( 输出模式)
Output mode主要负责控制输出字元的处理方式。输出字元在传送到序列埠或显示器之前是如何被程序来处理。
输出模式是利用termios结构的c_oflag的标志来加以控制，其定义的方式皆以OR来加以组合。
        OPOST ：启用具体实现自行定义的输出处理。
        OLCUC ：(不属于 POSIX) 将输出中的小写字母映射为大写字母。
        ONLCR ：(XSI) 将输出中的新行符映射为回车-换行。
        OCRNL ：将输出中的回车映射为新行符
        ONOCR ：不在第 0 列输出回车。
        ONLRET ：不输出回车。
        OFILL ：发送填充字符作为延时，而不是使用定时来延时。
        OFDEL ：(不属于 POSIX) 填充字符是 ASCII DEL (0177)。如果不设置，填充字符则是 ASCII NUL。
        NLDLY ：新行延时掩码。取值为 NL0 和 NL1。
        CRDLY ：回车延时掩码。取值为 CR0, CR1, CR2, 或 CR3。
        TABDLY ：水平跳格延时掩码。取值为 TAB0, TAB1, TAB2, TAB3 (或 XTABS)。取值为 TAB3，即 XTABS，将扩展跳格为空格 (每个跳格符填充 8 个空格)。(?)
        BSDLY ：回退延时掩码。取值为 BS0 或 BS1。(从来没有被实现过)
        VTDLY ：竖直跳格延时掩码。取值为 VT0 或 VT1。
        FFDLY ：进表延时掩码。取值为 FF0 或 FF1。
（3）c_cflag 标志常量：Control mode ( 控制模式)
Control mode主要用于控制终端设备的硬件设置。利用termios结构的c_cflag的标志来加以控制。控制模式用在序列线连接到数据设备，也可以用在与终端设备的交谈。
一般来说，改变终端设备的组态要比使用termios的控制模式来改变行(lines)的行为来得容易。
        CBAUD ：(不属于 POSIX) 波特率掩码 (4+1 位)。
        CBAUDEX ：(不属于 POSIX) 扩展的波特率掩码 (1 位)，包含在 CBAUD 中。
        (POSIX 规定波特率存储在 termios 结构中，并未精确指定它的位置，而是提供了函数 cfgetispeed() 和 cfsetispeed() 来存取它。一些系统使用 c_cflag 中 CBAUD 选择的位，其他系统使用单独的变量，例如 sg_ispeed 和 sg_ospeed 。)
        CSIZE：字符长度掩码（传送或接收字元时用的位数）。取值为 CS5（传送或接收字元时用5bits）, CS6, CS7, 或 CS8。
        CSTOPB ：设置两个停止位，而不是一个。
        CREAD ：打开接受者。
        PARENB ：允许输出产生奇偶信息以及输入的奇偶校验（启用同位产生与侦测）。
        PARODD ：输入和输出是奇校验（使用奇同位而非偶同位）。
        HUPCL ：在最后一个进程关闭设备后，降低 modem 控制线 (挂断)。(?)
        CLOCAL ：忽略 modem 控制线。
        LOBLK :(不属于 POSIX) 从非当前 shell 层阻塞输出(用于 shl )。(?)
        CIBAUD :(不属于 POSIX) 输入速度的掩码。CIBAUD 各位的值与 CBAUD 各位相同，左移了 IBSHIFT 位。
        CRTSCTS :(不属于 POSIX) 启用 RTS/CTS (硬件) 流控制。
（4）c_lflag 标志常量：Local mode ( 局部模式)
    Local mode主要用来控制终端设备不同的特色。利用termios结构里的c_lflag的标志来设定局部模式。
    在巨集中有两个比较重要的标志：
    1.ECHO：它可以让你阻止键入字元的回应。
    2.ICANON(正规模式)标志，它可以对所接收的字元在两种不同的终端设备模式之间来回切换。

        ISIG：当接受到字符 INTR, QUIT, SUSP, 或 DSUSP 时，产生相应的信号。
        ICANON：启用标准模式 (canonical mode)。允许使用特殊字符 EOF, EOL, EOL2, ERASE, KILL, LNEXT, REPRINT, STATUS, 和 WERASE，以及按行的缓冲。
        XCASE:(不属于 POSIX; Linux 下不被支持) 如果同时设置了 ICANON，终端只有大写。输入被转换为小写，除了有前缀的字符。输出时，大写字符被前缀（某些系统指定的特定字符） ，小写字符被转换成大写。
        ECHO ：回显输入字符。
        ECHOE ：如果同时设置了 ICANON，字符 ERASE 擦除前一个输入字符，WERASE 擦除前一个词。
        ECHOK ：如果同时设置了 ICANON，字符 KILL 删除当前行。
        ECHONL ：如果同时设置了 ICANON，回显字符 NL，即使没有设置 ECHO。
        ECHOCTL ：(不属于 POSIX) 如果同时设置了 ECHO，除了 TAB, NL, START, 和 STOP 之外的 ASCII 控制信号被回显为 ^X, 这里 X 是比控制信号大 0x40 的 ASCII 码。例如，字符 0x08 (BS) 被回显为 ^H。
        ECHOPRT ：(不属于 POSIX) 如果同时设置了 ICANON 和 IECHO，字符在删除的同时被打印。
        ECHOKE ：(不属于 POSIX) 如果同时设置了 ICANON，回显 KILL 时将删除一行中的每个字符，如同指定了 ECHOE 和 ECHOPRT 一样。
        DEFECHO :(不属于 POSIX) 只在一个进程读的时候回显。
        FLUSHO :(不属于 POSIX; Linux 下不被支持) 输出被刷新。这个标志可以通过键入字符 DISCARD 来开关。
        NOFLSH :禁止在产生 SIGINT, SIGQUIT 和 SIGSUSP 信号时刷新输入和输出队列，即关闭queue中的flush。
        TOSTOP :向试图写控制终端的后台进程组发送 SIGTTOU 信号（传送欲写入的信息到后台处理）。
        PENDIN :(不属于 POSIX; Linux 下不被支持) 在读入下一个字符时，输入队列中所有字符被重新输出。(bash 用它来处理 typeahead)
        IEXTEN :启用实现自定义的输入处理。这个标志必须与 ICANON 同时使用，才能解释特殊字符 EOL2，LNEXT，REPRINT 和 WERASE，IUCLC 标志才有效。
（5）c_cc 数组：特殊控制字元
    可提供使用者设定一些特殊的功能，
    如Ctrl+C的字元组合。
    特殊控制字元主要是利用termios结构里c_cc的阵列成员来做设定。
    c_cc阵列主要用于正规与非正规两种环境，但要注意的是正规与非正规不可混为一谈。
其定义了特殊的控制字符。符号下标 (初始值) 和意义为：
        VINTR：(003, ETX, Ctrl-C, or also 0177, DEL, rubout) 中断字符。发出 SIGINT 信号。当设置 ISIG 时可被识别，不再作为输入传递。
        VQUIT ：(034, FS, Ctrl-) 退出字符。发出 SIGQUIT 信号。当设置 ISIG 时可被识别，不再作为输入传递。
        VERASE ：(0177, DEL, rubout, or 010, BS, Ctrl-H, or also #) 删除字符。删除上一个还没有删掉的字符，但不删除上一个 EOF 或行首。当设置 ICANON 时可被识别，不再作为输入传递。
        VKILL ：(025, NAK, Ctrl-U, or Ctrl-X, or also @) 终止字符。删除自上一个 EOF 或行首以来的输入。当设置 ICANON 时可被识别，不再作为输入传递。
        VEOF ：(004, EOT, Ctrl-D) 文件尾字符。更精确地说，这个字符使得 tty 缓冲中的内容被送到等待输入的用户程序中，而不必等到 EOL。如果它是一行的第一个字符，那么用户程序的 read() 将返回 0，指示读到了 EOF。当设置 ICANON 时可被识别，不再作为输入传递。
        VMIN :非 canonical 模式读的最小字符数（MIN主要是表示能满足read的最小字元数）。
        VEOL :(0, NUL) 附加的行尾字符。当设置 ICANON 时可被识别。
        VTIME ：非 canonical 模式读时的延时，以十分之一秒为单位。
        VEOL2 ：(not in POSIX; 0, NUL) 另一个行尾字符。当设置 ICANON 时可被识别。
        VSWTCH ：(not in POSIX; not supported under Linux; 0, NUL) 开关字符。(只为 shl 所用。)
        VSTART ：(021, DC1, Ctrl-Q) 开始字符。重新开始被 Stop 字符中止的输出。当设置 IXON 时可被识别，不再作为输入传递。
        VSTOP ：(023, DC3, Ctrl-S) 停止字符。停止输出，直到键入 Start 字符。当设置 IXON 时可被识别，不再作为输入传递。
        VSUSP ：(032, SUB, Ctrl-Z) 挂起字符。发送 SIGTSTP 信号。当设置 ISIG 时可被识别，不再作为输入传递。
        VDSUSP ：(not in POSIX; not supported under Linux; 031, EM, Ctrl-Y) 延时挂起信号。当用户程序读到这个字符时，发送 SIGTSTP 信号。当设置 IEXTEN 和 ISIG，并且系统支持作业管理时可被识别，不再作为输入传递。
        VLNEXT ：(not in POSIX; 026, SYN, Ctrl-V) 字面上的下一个。引用下一个输入字符，取消它的任何特殊含义。当设置 IEXTEN 时可被识别，不再作为输入传递。
        VWERASE ：(not in POSIX; 027, ETB, Ctrl-W) 删除词。当设置 ICANON 和 IEXTEN 时可被识别，不再作为输入传递。
        VREPRINT ：(not in POSIX; 022, DC2, Ctrl-R) 重新输出未读的字符。当设置 ICANON 和 IEXTEN 时可被识别，不再作为输入传递。
        VDISCARD ：(not in POSIX; not supported under Linux; 017, SI, Ctrl-O) 开关：开始/结束丢弃未完成的输出。当设置 IEXTEN 时可被识别，不再作为输入传递。
        VSTATUS ：(not in POSIX; not supported under Linux; status request: 024, DC4, Ctrl-T).
        这些符号下标值是互不相同的，除了 VTIME，VMIN 的值可能分别与 VEOL，VEOF 相同。 (在 non-canonical 模式下，特殊字符的含义更改为延时含义。MIN 表示应当被读入的最小字符数。TIME 是以十分之一秒为单位的计时器。如果同时设置了它们，read 将等待直到至少读入一个字符，一旦读入 MIN 个字符或者从上次读入字符开始经过了 TIME 时间就立即返回。如果只设置了 MIN，read 在读入 MIN 个字符之前不会返回。如果只设置了 TIME，read 将在至少读入一个字符，或者计时器超时的时候立即返回。如果都没有设置，read 将立即返回，只给出当前准备好的字符。)
（6）   MIN与TIME组合有以下四种：
        1、 MIN = 0 , TIME =0
                      有READ立即回传
                      否则传回 0 ,不读取任何字元
        2、 MIN = 0 , TIME >0
         TIME specifies the limit for a timer in tenths of a second(十分之一秒）.  
         The timer is started  when  read  is  called.   read returns  either  
         when at least one byte of data is available, or when the timer expires.  
         If the timer expires without any  input  becoming available, read returns 0.
        3、 MIN > 0 , TIME =0
                      READ 会等待,直到MIN字元可读
        4、 MIN > 0 , TIME > 0
                      每一格字元之间计时器即会被启动
                      READ 会在读到MIN字元,传回值或TIME的字元计时(1/10秒)超过时将值传回
         TIME specifies the limit for a timer in tenths of
         a second.  Once an initial byte of input becomes available, the timer
         is  restarted  after  each further byte is received.  read(2) returns
         either when the lesser of the number of bytes requested or  MIN  byte
         have  been read, or when the inter-byte timeout expires.  Because the
         timer is only started after the initial byte  becomes  available,  at
         least one byte will be read.

//    c_cc[VTIME] = 1;
//    c_cc[VMIN]  = 255;
int serial_recv(unsigned char *recvbuf, int *len, int waittime)
{
        int read_bytes_num = -1, rt = -1;
        struct timeval tv;
        fd_set readset;

        tv.tv_sec = waittime;
        tv.tv_usec = 0;
        FD_ZERO(&readset);
        FD_SET(fd, &readset);

        rt = FD_ISSET(fd, &readset);
        rt = select(fd+1, &readset, NULL, NULL, &tv);
        if(rt > 0){
                read_bytes_num = read(fd, recvbuf, 256);
                if(read_bytes_num > 0){
                        *len = read_bytes_num;
                        return 0;
                } else {
                        printf("serial port sending failed
");
                        return -1;
                }
        } else {
                printf("Fuc select error
");
                return -1;
        }

        return 0;
}

注：应用中根据实测情况调节MIN和TIME值，如出现不能丢失某个字节情况。

应用示例

演示串口收发数据，程序可接收字符串或16进制数据输入，并返回串口接收到的设备数据。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <termios.h>
#include <fcntl.h>
#include <errno.h>
#include <ctype.h>

// serial
#define BUF_SIZE    256    

static struct termios save_termios;
static int  ttysavefd = -1;
static enum {RESET , RAW , CBREAK} ttystate = RESET;

int speed_arr[] = { B115200, B57600, B38400, B19200, B9600, B4800, B2400, B1200, B300};
int name_arr[] = {115200, 57600, 38400, 19200, 9600, 4800, 2400, 1200, 300};
unsigned char crc8(unsigned char arr[], int len)
{
    int i = 0; 
    unsigned char crc = 0;

    for(i = 0; i < len; i++){
        crc ^= arr[i];
    }

    return crc;
}

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 fd");
                                return;
                        }
                        tcflush(fd,TCIOFLUSH);
                }
        }

        return ;
}

int set_Parity(int fd,int databits,int stopbits,int parity)
{
    struct termios options;
    if  ( tcgetattr( fd,&options)  !=  0) {
        perror("SetupSerial 1");
        return 1;
    }
    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
"); return 1;
    }
    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
");
            return 1;
    }
    switch (stopbits)
    {
        case 1:
            options.c_cflag &= ~CSTOPB;
            break;
        case 2:
            options.c_cflag |= CSTOPB;
            break;
        default:
            fprintf(stderr,"Unsupported stop bits
");
            return 1;
    }
    /* Set input parity option */
    if (parity != 'n')
        options.c_iflag |= INPCK;
    tcflush(fd,TCIFLUSH);
    options.c_cc[VTIME] = 200;
    options.c_cc[VMIN] = 0; /* Update the options and do it NOW */
    if (tcsetattr(fd,TCSANOW,&options) != 0)
    {
        perror("SetupSerial 3");
        return 1;
    }
    return 0;
}

int tty_raw(int fd)
{
        int err;
        struct termios buf;

        if(ttystate != RESET){
                errno = EINVAL;
                return -1;
        }
        if(tcgetattr(fd, &buf)<0)
                return -1;
        save_termios = buf;

        buf.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);

        buf.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);

        buf.c_cflag &= ~(CSIZE | PARENB);

        buf.c_cflag |= CS8;

        buf.c_oflag &= ~(OPOST);
        buf.c_cc[VMIN] = 1;
        buf.c_cc[VTIME] = 0;
        if(tcsetattr(fd, TCSAFLUSH, &buf)<0)
                return -1;

        if(tcgetattr(fd, &buf)<0){
                err = errno;
                tcsetattr(fd, TCSAFLUSH, &save_termios);
                errno = err;
                return -1;
        }

        if((buf.c_lflag & (ECHO | ICANON | IEXTEN | ISIG)) || (buf.c_iflag & (BRKINT | ICRNL | INPCK | ISTRIP | IXON )) || (buf.c_cflag & ( CSIZE | PARENB | CS8)) != CS8 || (buf.c_oflag & OPOST) || buf.c_cc[VMIN]!=1 || buf.c_cc[VTIME]!=0){
                tcsetattr(fd, TCSAFLUSH, &save_termios);
                errno = EINVAL;
                return -1;

        }

        ttystate = RAW;
        ttysavefd = fd;
        return 0;

}

int main(int argc, char *argv[])
{
    int fd = 0;
    char tx_buf[BUF_SIZE*2], rx_buf[BUF_SIZE*2];
    unsigned char tx_buf_tmp[BUF_SIZE];
    unsigned char *txp = NULL;
    int speed = 0, len = 0;
    char pserial[3]  = {0}, flag_data = 0;
    int i = 0, j = 0;
    
    printf("Usage: %s /dev/ttyUSBx -s[115200|57600|9600|4800|2400] -p[8n1|7o2|8e1] -f[1|2]
", argv[0]);
    printf("-s: specify the bps, 115200, 57600, 9600, 4800, 2400...
");
    printf("-p: specify the databits, parity and stopbits.
            
	databits: 8 or 7, parity: o, e, n, stopbits: 1 or 2
");
    printf("-f: specify the following data format. string: 1, hex: 2.
");

    if(5 != argc){
        printf("CMD error! Please repeat!
");    
        exit(-1);
    }
    
    if(strncmp("-s", argv[2], 2) == 0){
        speed = atoi(&argv[2][2]);
    } else {
        exit(-1);
    }

    if(strncmp("-p", argv[3], 2) == 0){
        strncpy(pserial, &argv[3][2], 3);
    } else {
        exit(-1);
    }

    if(strncmp("-f", argv[4], 2) == 0){
        flag_data = argv[4][2] - '0';
    } else {
        exit(-1);
    }

    fd = open(argv[1], O_RDWR);
    if(fd == -1){
        perror("open ttyUSBx");
        exit(1);
    }
#if 1
    tty_raw(fd);

    set_speed(fd, speed);
    set_Parity(fd, pserial[0]-'0', pserial[2]-'0', pserial[1]);
#endif

    printf("====
Input format [%d] data(1: string, 2: hex): 
", flag_data);
    while(fgets(tx_buf, sizeof(tx_buf), stdin)){
        len = strlen(tx_buf);

        txp = (unsigned char *)tx_buf;
        if(flag_data == 2){ // deal with hex
            i = 0, j = 0;
            while(isspace(tx_buf[i]) != 0) i++; // eat space
            for(; i < len; i++){
                while(isspace(tx_buf[i]) == 0) i++;
                if((isxdigit(tx_buf[i-2]) != 0) && (isxdigit(tx_buf[i-1]) != 0)){
//                    tx_buf_tmp[j++] = (tx_buf[i-2] - '0')*16 + (tx_buf[i-1] - '0');
                    tx_buf_tmp[j++] = (unsigned char)(strtol(tx_buf+(i-2), NULL, 16) & 0xFF);
                } else {
                    break;
                }    
                while(isspace(tx_buf[++i]) != 0); // eat space
            }
            if((i < len) || (j == 0)){
                printf("Input error, please repeat:
");
                continue;
            }
            txp = tx_buf_tmp;
            len = j;

            printf("Will send %d [hex] data:", len);
            for(j = 0; j < len; j++){
                if(j % 10 == 0)printf("
");
                printf("%.2X ", tx_buf_tmp[j]&0xFF);
            }
            printf("
");
        } else {
            if(tx_buf[len-1] == '
')
                len--;
        }

        write(fd, txp, len);
        sync();
        len = read(fd, rx_buf, sizeof(rx_buf));
        if(len < 0){
            printf("recevice error, continue...
");
            continue;
        }
        if(flag_data == 2){ //deal with hex
            printf("receive %d [hex] data:", len);
            for(i = 0; i < len; i++){
                if(i % 10 == 0)printf("
");
                printf("%.2X ", rx_buf[i]&0xFF);
            }
            printf("
");
        } else {
            printf("receive %d [string] data:[%s]
", len, rx_buf);
        }
        printf("------
");
    }

    close(fd);
    return 0;
}