2. 程式人生 > >linux串列埠程式設計（termios結構體說明）

linux串列埠程式設計（termios結構體說明）

阿新 • • 發佈：2018-12-25

termios結構體說明

轉https://www.cnblogs.com/li-hao/archive/2012/02/19/2358158.html

termios結構體中，該結構體一般包括如下的成員：
tcflag_t       c_iflag;      
tcflag_t       c_oflag;      
tcflag_t       c_cflag;      
tcflag_t       c_lflag;     
cc_t            c_cc[NCCS];

  
 
 其具體意義如下
 
c_iflag：輸入模式標誌，控制終端輸入方式，具體引數如下所示。

c_iflag引數表
鍵值說明
IGNBRK       忽略BREAK鍵輸入
BRKINT       如果設定了IGNBRK，BREAK鍵的輸入將被忽略，如果設定了BRKINT ，將產生SIGINT中斷
IGNPAR       忽略奇偶校驗錯誤
PARMRK     標識奇偶校驗錯誤
INPCK        允許輸入奇偶校驗
ISTRIP       去除字元的第8個位元
INLCR        將輸入的NL（換行）轉換成CR（回車）
IGNCR       忽略輸入的回車
ICRNL        將輸入的回車轉化成換行（如果IGNCR未設定的情況下）
IUCLC        將輸入的大寫字元轉換成小寫字元（非POSIX）
IXON         允許輸入時對XON/XOFF流進行控制
IXANY        輸入任何字元將重啟停止的輸出
IXOFF        允許輸入時對XON/XOFF流進行控制
IMAXBEL   當輸入佇列滿的時候開始響鈴，Linux在使用該引數而是認為該引數總是已經設定

 

c_oflag：       輸出模式標誌，控制終端輸出方式，具體引數如下所示。
c_oflag引數
鍵值說明
OPOST       處理後輸出
OLCUC      將輸入的小寫字元轉換成大寫字元（非POSIX）
ONLCR      將輸入的NL（換行）轉換成CR（回車）及NL（換行）
OCRNL      將輸入的CR（回車）轉換成NL（換行）
ONOCR      第一行不輸出回車符
ONLRET      不輸出回車符
OFILL         傳送填充字元以延遲終端輸出
OFDEL       以ASCII碼的DEL作為填充字元，如果未設定該引數，填充字元將是NUL（‘/0’）（非POSIX）
NLDLY       換行輸出延時，可以取NL0（不延遲）或NL1（延遲0.1s）
CRDLY       回車延遲，取值範圍為：CR0、CR1、CR2和 CR3
TABDLY     水平製表符輸出延遲，取值範圍為：TAB0、TAB1、TAB2和TAB3
BSDLY       空格輸出延遲，可以取BS0或BS1
VTDLY       垂直製表符輸出延遲，可以取VT0或VT1
FFDLY       換頁延遲，可以取FF0或FF1

c_cflag：控制模式標誌，指定終端硬體控制資訊，具體引數如下所示。
c_oflag引數
鍵值說明
CBAUD             波特率（4+1位）（非POSIX）
CBAUDEX        附加波特率（1位）（非POSIX）
CSIZE              字元長度，取值範圍為CS5、CS6、CS7或CS8
CSTOPB         設定兩個停止位
CREAD           使用接收器
PARENB         使用奇偶校驗
PARODD        對輸入使用奇偶校驗，對輸出使用偶校驗
HUPCL           關閉裝置時掛起
CLOCAL         忽略調變解調器線路狀態
CRTSCTS         使用RTS/CTS流控制


c_lflag：本地模式標誌，控制終端編輯功能，具體引數如下所示。
c_lflag引數
鍵值說明
ISIG                  當輸入INTR、QUIT、SUSP或DSUSP時，產生相應的訊號
ICANON           使用標準輸入模式
XCASE            在ICANON和XCASE同時設定的情況下，終端只使用大寫。如果只設置了XCASE，則輸入字元將被轉換為小寫字元，除非字元使用了轉義字元（非POSIX，且Linux不支援該引數）
ECHO               顯示輸入字元
ECHOE            如果ICANON同時設定，ERASE將刪除輸入的字元，WERASE將刪除輸入的單詞
ECHOK            如果ICANON同時設定，KILL將刪除當前行
ECHONL          如果ICANON同時設定，即使ECHO沒有設定依然顯示換行符
ECHOPRT        如果ECHO和ICANON同時設定，將刪除打印出的字元（非POSIX）
TOSTOP           向後臺輸出傳送SIGTTOU訊號

 

與此結構體相關的函式
（一）tcgetattr()      //   tc  get attr
1.原型
int tcgetattr  (int fd,struct termois & termios_p);
2.功能 
取得終端介質（fd）初始值，並把其值 賦給temios_p;函式可以從後臺程序中呼叫；

但是，終端屬性可能被後來的前臺程序所改變。


（二）tcsetattr()          //tc  set  attr
1.原型
int tcsetattr   (int fd,int actions,const struct    termios *termios_p);
2.功能
設定與終端相關的引數 (除非需要底層支援卻無法滿足)，使用 termios_p 引用的 termios 結構。optional_actions （tcsetattr函式的第二個引數）指定了什麼時候改變會起作用： 
TCSANOW：      改變立即發生  
TCSADRAIN：    改變在所有寫入 fd 的輸出都被傳輸後生效。這個函式應當用於修改影響輸出的引數時使用。(當前輸出完成時將值改變)  
TCSAFLUSH ：   改變在所有寫入 fd 引用的物件的輸出都被傳輸後生效，所有已接受但未讀入的輸入都在改變發生前丟棄(同TCSADRAIN，但會捨棄當前所有值)。 


（三）tcsendbreak()    //  tc send break
  傳送連續的 0 值位元流，持續一段時間，如果終端使用非同步序列資料傳輸的話。如果 duration 是 0，它至少傳輸 0.25 秒，不會超過 0.5 秒。如果 duration 非零，它傳送的時間長度由實現定義。 
如果終端並非使用非同步序列資料傳輸，tcsendbreak() 什麼都不做。


（四）tcdrain()            //tc drain
等待直到所有寫入 fd 引用的物件的輸出都被傳輸。


（五）tcflush()           //tc   flush
丟棄要寫入 引用的物件，但是尚未傳輸的資料，或者收到但是尚未讀取的資料，取決於 queue_selector 的值：

TCIFLUSH ：   重新整理收到的資料但是不讀  
TCOFLUSH ： 重新整理寫入的資料但是不傳送  
TCIOFLUSH ：同時重新整理收到的資料但是不讀，並且重新整理寫入的資料但是不傳送 

 

（六）tcflow()            //tc  flow  
掛起 fd 引用的物件上的資料傳輸或接收，取決於 action 的值：

TCOOFF ：  掛起輸出  
TCOON ：   重新開始被掛起的輸出  
TCIOFF ：   傳送一個 STOP 字元，停止終端裝置向系統傳送資料  
TCION ：     傳送一個 START 字元，使終端裝置向系統傳輸資料  
開啟一個終端裝置時的預設設定是輸入和輸出都沒有掛起。


(七)波特率函式 
被用來獲取和設定 termios 結構中，輸入和輸出波特率的值。新值不會馬上生效，直到成功呼叫了 tcsetattr() 函式。
設定速度為 B0 使得 modem "掛機"。與 B38400 相應的實際位元率可以用 setserial(8) 調整。 
輸入和輸出波特率被保存於 termios 結構中。 
cfmakeraw 設定終端屬性如下： 

             //輸入模式標誌
termios_p->c_iflag &= ~( IGNBRK | BRKINT  | PARMRK | ISTRIP | INLCR | IGNCR  | ICRNL | IXON   );

//  輸出模式標誌
termios_p->c_oflag &= ~OPOST;

//  本地模式標誌 
termios_p->c_lflag &= ~(   ECHO   |   ECHONL   |   ICANON   |    ISIG   |   IEXTEN   );
             
 //  控制模式標誌
termios_p->c_cflag &= ~(CSIZE   |   PARENB);

termios_p->c_cflag |= CS8;

cf get o speed

cf  set o speed 

cf  get i speed

cf set i  speed

1.cfgetospeed()         返回 termios_p 指向的 termios 結構中儲存的輸出波特率 
2.cfsetospeed()         設定 termios_p 指向的 termios 結構中儲存的輸出波特率為 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.cfgetispeed() 返回 termios 結構中儲存的輸入波特率。 
4.cfsetispeed() 設定 termios 結構中儲存的輸入波特率為 speed。如果輸入波特率被設為0，實際輸入波特率將等於輸出波特率。

 
RETURN VALUE 返回值
1.cfgetispeed()      返回 termios 結構中儲存的輸入波特率。 
2.cfgetospeed()     返回 termios 結構中儲存的輸出波特率。 
3.其他函式返回： 
  （1）0：成功 
  （2）  -1：失敗，
    並且為 errno 置值來指示錯誤。 

tcsetattr()   任何一個設定屬性設定成功，都會返回成功，但因為要設定幾個屬性，但並不確定每個個都成成功，因此，要呼叫tcgetattr 來讀取驗證。

 


注意 tcsetattr() 返回成功，如果任何所要求的修改可以實現的話。因此，當進行多重修改時，應當在這個函式之後再次呼叫 tcgetattr() 來檢測是否所有修改都成功實現

 

#if 0

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

獲取 fd 串列埠終端的屬性，儲存到 tremios_p
int tcgetattr(int fd, struct termios *termios_p);

設定 tremios_p 串列埠終端屬性到 fd 中，使用 optional_action
int tcsetattr(int fd, int optional_actions,
			const struct termios *termios_p);
optional_actions 可取值：
TCSANOW   立即生效
TCSADRAIN 所有寫到 fd 的輸出已完成後才生效
TCSAFLUSH 所有寫到 fd 的輸出已完成，並且輸入已接收完成，
但還未被讀取

int tcsendbreak(int fd, int duration);

int tcdrain(int fd);

重新整理串列埠終端 fd。queue_selector 可取值：
TCIFLUSH   重新整理接收的資料而不讀
TCOFLUSH   重新整理寫的資料而不傳送
TCIOFLUSH  重新整理接收和寫的資料而不讀和傳送
int tcflush(int fd, int queue_selector);

int tcflow(int fd, int action);

void cfmakeraw(struct termios *termios_p);

獲取輸入波特率
speed_t cfgetispeed(const struct termios *termios_p);

獲取輸出波特率
speed_t cfgetospeed(const struct termios *termios_p);

設定輸入波特率
int cfsetispeed(struct termios *termios_p, speed_t speed);

設定輸出波特率
int cfsetospeed(struct termios *termios_p, speed_t speed);

設定輸入/輸出波特率
int cfsetspeed(struct termios *termios_p, speed_t speed);


struct termios 結構體至少包含以下成員：

tcflag_t c_iflag;      /* input modes */
tcflag_t c_oflag;      /* output modes */
tcflag_t c_cflag;      /* control modes */
tcflag_t c_lflag;      /* local modes */
cc_t     c_cc[NCCS];   /* special characters */

非規範模式下，輸入立即可用，對 read 來說，c_cc[NCSS] 陣列的
c_cc[VMIN] 和 c_cc[VTIME] 有以下四種情況：

c_cc[VMIN] == 0, c_cc[VTIME] == 0：
輪詢讀，無資料立即返回，read 返回 0

c_cc[VMIN] >  0, c_cc[VTIME] == 0：
阻塞讀，直到讀到請求的位元組數（即 c_cc[VMIN] 個位元組）

c_cc[VMIN] == 0, c_cc[VTIME] >  0：
帶超時的讀，如果在超時時間內有資料，則返回資料，如果超時到期，
沒有資料，則返回 0

c_cc[VMIN] >  0, c_cc[VTIME] >  0：
帶超時及請求位元組的讀，在超時期內等待請求的位元組數，超時到期，
不管請求的資料是否滿足都會返回，如果請求的資料滿足，會立即返回。


原始模式的典型配置：
termios_p->c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP
			| INLCR | IGNCR | ICRNL | IXON);
termios_p->c_oflag &= ~OPOST;
termios_p->c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
termios_p->c_cflag &= ~(CSIZE | PARENB);
termios_p->c_cflag |= CS8;

以上函式的返回值：

除 cfgetispeed 和 cfgetospeed 返回波特率外，其它的函式：
成功返回 0，失敗返回 -1
注意：tcsetattr 函式只有請求的設定有一個生效，就會返回成功，
因此要驗證是否全部設定成功，應該使用 tcgetattr 獲取
屬性後，與設定的屬性進行對比來驗證是否全部設定成功。

#endif

程式設計：

開啟串列埠

/*

在 Linux 下串列埠檔案是位於 /dev 下的

開啟串列埠是通過使用標準的檔案開啟函式open操作：


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

static int fd;

int uart_open(int fd,const char *pathname)
{
    assert(pathname);

    fd = open(pathname,O_RDWR|O_NOCTTY| O_NONBLOCK);
    if(fd == -1)
    {
        perror("Open UART failed!");
        return -1;
    }
    return fd;
}

其中：

O_NOCTTY

如果路徑名指向終端裝置，不要把這個裝置用作控制終端

O_NONBLOCK

如果路徑名指向 FIFO/塊檔案/字元檔案，則把檔案的開啟和後繼 I/O設定為非阻塞模式（nonblocking mode）

對於串列埠的開啟操作，必須使用O_NOCTTY引數，它表示開啟的是一個終端裝置，程式不會成為該埠的控制終端。如果不使用此標誌，任務的一個輸入都會影響程序。如鍵盤上過來的Ctrl+C中止訊號等都將影響程序。

設定串列埠

串列埠初始化需要設定串列埠波特率，資料流控制，幀的格式(即資料位個數，停止位，校驗位,資料流控制)

int uart_set(int fd,int baude,int c_flow,int bits,char parity,int stop)
{
    struct termios options;

    /*獲取終端屬性*/
    if(tcgetattr(fd,&options) < 0)
    {
        perror("tcgetattr error");
        return -1;
    }

    /*設定輸入輸出波特率，兩者保持一致*/
    switch(baude)
    {
        case 4800:
            cfsetispeed(&options,B4800);
            cfsetospeed(&options,B4800);
            break;
        case 9600:
            cfsetispeed(&options,B9600);
            cfsetospeed(&options,B9600);
            break;
        case 19200:
            cfsetispeed(&options,B19200);
            cfsetospeed(&options,B19200);
            break;
        case 38400:
            cfsetispeed(&options,B38400);
            cfsetospeed(&options,B38400);
            break;
        default:
            fprintf(stderr,"Unkown baude!\n");
            return -1;
    }

    /*設定控制模式*/
    options.c_cflag |= CLOCAL;//保證程式不佔用串列埠
    options.c_cflag |= CREAD;//保證程式可以從串列埠中讀取資料

    /*設定資料流控制*/
    switch(c_flow)
    {
        case 0://不進行流控制
            options.c_cflag &= ~CRTSCTS;
            break;
        case 1://進行硬體流控制
            options.c_cflag |= CRTSCTS;
            break;
        case 2://進行軟體流控制
            options.c_cflag |= IXON|IXOFF|IXANY;
            break;
        default:
            fprintf(stderr,"Unkown c_flow!\n");
            return -1;
    }

    /*設定資料位*/
    switch(bits)
    {
        case 5:
            options.c_cflag &= ~CSIZE;//遮蔽其它標誌位
            options.c_cflag |= CS5;
            break;
        case 6:
            options.c_cflag &= ~CSIZE;//遮蔽其它標誌位
            options.c_cflag |= CS6;
            break;
        case 7:
            options.c_cflag &= ~CSIZE;//遮蔽其它標誌位
            options.c_cflag |= CS7;
            break;
        case 8:
            options.c_cflag &= ~CSIZE;//遮蔽其它標誌位
            options.c_cflag |= CS8;
            break;
        default:
            fprintf(stderr,"Unkown bits!\n");
            return -1;
    }

    /*設定校驗位*/
    switch(parity)
    {
        /*無奇偶校驗位*/
        case 'n':
        case 'N':
            options.c_cflag &= ~PARENB;//PARENB：產生奇偶位，執行奇偶校驗
            options.c_cflag &= ~INPCK;//INPCK：使奇偶校驗起作用
            break;
        /*設為空格,即停止位為2位*/
        case 's':
        case 'S':
            options.c_cflag &= ~PARENB;//PARENB：產生奇偶位，執行奇偶校驗
            options.c_cflag &= ~CSTOPB;//CSTOPB：使用兩位停止位
            break;
        /*設定奇校驗*/
        case 'o':
        case 'O':
            options.c_cflag |= PARENB;//PARENB：產生奇偶位，執行奇偶校驗
            options.c_cflag |= PARODD;//PARODD：若設定則為奇校驗,否則為偶校驗
            options.c_cflag |= INPCK;//INPCK：使奇偶校驗起作用
            options.c_cflag |= ISTRIP;//ISTRIP：若設定則有效輸入數字被剝離7個位元組，否則保留全部8位
            break;
        /*設定偶校驗*/
        case 'e':
        case 'E':
            options.c_cflag |= PARENB;//PARENB：產生奇偶位，執行奇偶校驗
            options.c_cflag &= ~PARODD;//PARODD：若設定則為奇校驗,否則為偶校驗
            options.c_cflag |= INPCK;//INPCK：使奇偶校驗起作用
            options.c_cflag |= ISTRIP;//ISTRIP：若設定則有效輸入數字被剝離7個位元組，否則保留全部8位
            break;
        default:
            fprintf(stderr,"Unkown parity!\n");
            return -1;
    }

    /*設定停止位*/
    switch(stop)
    {
        case 1:
            options.c_cflag &= ~CSTOPB;//CSTOPB：使用兩位停止位
            break;
        case 2:
            options.c_cflag |= CSTOPB;//CSTOPB：使用兩位停止位
            break;
        default:
            fprintf(stderr,"Unkown stop!\n");
            return -1;
    }

    /*設定輸出模式為原始輸出*/
    options.c_oflag &= ~OPOST;//OPOST：若設定則按定義的輸出處理，否則所有c_oflag失效

    /*設定本地模式為原始模式*/
    options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
    /*
     *ICANON：允許規範模式進行輸入處理
     *ECHO：允許輸入字元的本地回顯
     *ECHOE：在接收EPASE時執行Backspace,Space,Backspace組合
     *ISIG：允許訊號
     */

    /*設定等待時間和最小接受字元*/
    options.c_cc[VTIME] = 0;//可以在select中設定
    options.c_cc[VMIN] = 1;//最少讀取一個字元

    /*如果發生資料溢位，只接受資料，但是不進行讀操作*/
    tcflush(fd,TCIFLUSH);

    /*啟用配置*/
    if(tcsetattr(fd,TCSANOW,&options) < 0)
    {
        perror("tcsetattr failed");
        return -1;
    }

    return 0;

}

讀寫串列埠

ssize_t safe_write(int fd, const void *vptr, size_t n)
{
    size_t  nleft;
    ssize_t nwritten;
    const char *ptr;

    ptr = vptr;
    nleft = n;

    while(nleft > 0)
    {
    if((nwritten = write(fd, ptr, nleft)) <= 0)
        {
            if(nwritten < 0&&errno == EINTR)
                nwritten = 0;
            else
                return -1;
        }
        nleft -= nwritten;
        ptr   += nwritten;
    }
    return(n);
}

ssize_t safe_read(int fd,void *vptr,size_t n)
{
    size_t nleft;
    ssize_t nread;
    char *ptr;

    ptr=vptr;
    nleft=n;

    while(nleft > 0)
    {
        if((nread = read(fd,ptr,nleft)) < 0)
        {
            if(errno == EINTR)//被訊號中斷
                nread = 0;
            else
                return -1;
        }
        else
        if(nread == 0)
            break;
        nleft -= nread;
        ptr += nread;
    }
    return (n-nleft);
}

int uart_read(int fd,char *r_buf,size_t len)
{
    ssize_t cnt = 0;
    fd_set rfds;
    struct timeval time;

    /*將檔案描述符加入讀描述符集合*/
    FD_ZERO(&rfds);
    FD_SET(fd,&rfds);

    /*設定超時為15s*/
    time.tv_sec = 15;
    time.tv_usec = 0;

    /*實現串列埠的多路I/O*/
    ret = select(fd+1,&rfds,NULL,NULL,&time);
    switch(ret)
    {
        case -1:
            fprintf(stderr,"select error!\n");
            return -1;
        case 0:
            fprintf(stderr,"time over!\n");
            return -1;
        default:
            cnt = safe_read(fd,r_buf,len);
            if(cnt == -1)
            {
                fprintf(stderr,"read error!\n");
                return -1;
            }
            return cnt;
    }
}

int uart_write(int fd,const char *w_buf,size_t len)
{
    ssize_t cnt = 0;

    cnt = safe_write(fd,w_buf,len);
    if(cnt == -1)
    {
        fprintf(stderr,"write error!\n");
        return -1;
    }

    return cnt;
}

關閉串列埠

int uart_close(int fd)
{
    assert(fd);
    close(fd);

    /*可以在這裡做些清理工作*/

    return 0;
}

完整程式碼

 

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

static int ret;
static int fd;

/*
 * 安全讀寫函式
 */

ssize_t safe_write(int fd, const void *vptr, size_t n)
{
    size_t  nleft;
    ssize_t nwritten;
    const char *ptr;

    ptr = vptr;
    nleft = n;

    while(nleft > 0)
    {
    if((nwritten = write(fd, ptr, nleft)) <= 0)
        {
            if(nwritten < 0&&errno == EINTR)
                nwritten = 0;
            else
                return -1;
        }
        nleft -= nwritten;
        ptr   += nwritten;
    }
    return(n);
}

ssize_t safe_read(int fd,void *vptr,size_t n)
{
    size_t nleft;
    ssize_t nread;
    char *ptr;

    ptr=vptr;
    nleft=n;

    while(nleft > 0)
    {
        if((nread = read(fd,ptr,nleft)) < 0)
        {
            if(errno == EINTR)//被訊號中斷
                nread = 0;
            else
                return -1;
        }
        else
        if(nread == 0)
            break;
        nleft -= nread;
        ptr += nread;
    }
    return (n-nleft);
}

int uart_open(int fd,const char *pathname)
{
    assert(pathname);

    /*開啟串列埠*/
    fd = open(pathname,O_RDWR|O_NOCTTY|O_NDELAY);
    if(fd == -1)
    {
        perror("Open UART failed!");
        return -1;
    }

    /*清除串列埠非阻塞標誌*/
    if(fcntl(fd,F_SETFL,0) < 0)
    {
        fprintf(stderr,"fcntl failed!\n");
        return -1;
    }

    return fd;
}

int uart_set(int fd,int baude,int c_flow,int bits,char parity,int stop)
{
    struct termios options;

    /*獲取終端屬性*/
    if(tcgetattr(fd,&options) < 0)
    {
        perror("tcgetattr error");
        return -1;
    }


    /*設定輸入輸出波特率，兩者保持一致*/
    switch(baude)
    {
        case 4800:
            cfsetispeed(&options,B4800);
            cfsetospeed(&options,B4800);
            break;
        case 9600:
            cfsetispeed(&options,B9600);
            cfsetospeed(&options,B9600);
            break;
        case 19200:
            cfsetispeed(&options,B19200);
            cfsetospeed(&options,B19200);
            break;
        case 38400:
            cfsetispeed(&options,B38400);
            cfsetospeed(&options,B38400);
            break;
        default:
            fprintf(stderr,"Unkown baude!\n");
            return -1;
    }

    /*設定控制模式*/
    options.c_cflag |= CLOCAL;//保證程式不佔用串列埠
    options.c_cflag |= CREAD;//保證程式可以從串列埠中讀取資料

    /*設定資料流控制*/
    switch(c_flow)
    {
        case 0://不進行流控制
            options.c_cflag &= ~CRTSCTS;
            break;
        case 1://進行硬體流控制
            options.c_cflag |= CRTSCTS;
            break;
        case 2://進行軟體流控制
            options.c_cflag |= IXON|IXOFF|IXANY;
            break;
        default:
            fprintf(stderr,"Unkown c_flow!\n");
            return -1;
    }

    /*設定資料位*/
    switch(bits)
    {
        case 5:
            options.c_cflag &= ~CSIZE;//遮蔽其它標誌位
            options.c_cflag |= CS5;
            break;
        case 6:
            options.c_cflag &= ~CSIZE;//遮蔽其它標誌位
            options.c_cflag |= CS6;
            break;
        case 7:
            options.c_cflag &= ~CSIZE;//遮蔽其它標誌位
            options.c_cflag |= CS7;
            break;
        case 8:
            options.c_cflag &= ~CSIZE;//遮蔽其它標誌位
            options.c_cflag |= CS8;
            break;
        default:
            fprintf(stderr,"Unkown bits!\n");
            return -1;
    }

    /*設定校驗位*/
    switch(parity)
    {
        /*無奇偶校驗位*/
        case 'n':
        case 'N':
            options.c_cflag &= ~PARENB;//PARENB：產生奇偶位，執行奇偶校驗
            options.c_cflag &= ~INPCK;//INPCK：使奇偶校驗起作用
            break;
        /*設為空格,即停止位為2位*/
        case 's':
        case 'S':
            options.c_cflag &= ~PARENB;//PARENB：產生奇偶位，執行奇偶校驗
            options.c_cflag &= ~CSTOPB;//CSTOPB：使用兩位停止位
            break;
        /*設定奇校驗*/
        case 'o':
        case 'O':
            options.c_cflag |= PARENB;//PARENB：產生奇偶位，執行奇偶校驗
            options.c_cflag |= PARODD;//PARODD：若設定則為奇校驗,否則為偶校驗
            options.c_cflag |= INPCK;//INPCK：使奇偶校驗起作用
            options.c_cflag |= ISTRIP;//ISTRIP：若設定則有效輸入數字被剝離7個位元組，否則保留全部8位
            break;
        /*設定偶校驗*/
        case 'e':
        case 'E':
            options.c_cflag |= PARENB;//PARENB：產生奇偶位，執行奇偶校驗
            options.c_cflag &= ~PARODD;//PARODD：若設定則為奇校驗,否則為偶校驗
            options.c_cflag |= INPCK;//INPCK：使奇偶校驗起作用
            options.c_cflag |= ISTRIP;//ISTRIP：若設定則有效輸入數字被剝離7個位元組，否則保留全部8位
            break;
        default:
            fprintf(stderr,"Unkown parity!\n");
            return -1;
    }

    /*設定停止位*/
    switch(stop)
    {
        case 1:
            options.c_cflag &= ~CSTOPB;//CSTOPB：使用兩位停止位
            break;
        case 2:
            options.c_cflag |= CSTOPB;//CSTOPB：使用兩位停止位
            break;
        default:
            fprintf(stderr,"Unkown stop!\n");
            return -1;
    }

    /*設定輸出模式為原始輸出*/
    options.c_oflag &= ~OPOST;//OPOST：若設定則按定義的輸出處理，否則所有c_oflag失效

    /*設定本地模式為原始模式*/
    options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
    /*
     *ICANON：允許規範模式進行輸入處理
     *ECHO：允許輸入字元的本地回顯
     *ECHOE：在接收EPASE時執行Backspace,Space,Backspace組合
     *ISIG：允許訊號
     */

    /*設定等待時間和最小接受字元*/
    options.c_cc[VTIME] = 0;//可以在select中設定
    options.c_cc[VMIN] = 1;//最少讀取一個字元

    /*如果發生資料溢位，只接受資料，但是不進行讀操作*/
    tcflush(fd,TCIFLUSH);

    /*啟用配置*/
    if(tcsetattr(fd,TCSANOW,&options) < 0)
    {
        perror("tcsetattr failed");
        return -1;
    }

    return 0;
}

int uart_read(int fd,char *r_buf,size_t len)
{
    ssize_t cnt = 0;
    fd_set rfds;
    struct timeval time;

    /*將檔案描述符加入讀描述符集合*/
    FD_ZERO(&rfds);
    FD_SET(fd,&rfds);

    /*設定超時為15s*/
    time.tv_sec = 15;
    time.tv_usec = 0;

    /*實現串列埠的多路I/O*/
    ret = select(fd+1,&rfds,NULL,NULL,&time);
    switch(ret)
    {
        case -1:
            fprintf(stderr,"select error!\n");
            return -1;
        case 0:
            fprintf(stderr,"time over!\n");
            return -1;
        default:
            cnt = safe_read(fd,r_buf,len);
            if(cnt == -1)
            {
                fprintf(stderr,"read error!\n");
                return -1;
            }
            return cnt;
    }
}

int uart_write(int fd,const char *w_buf,size_t len)
{
    ssize_t cnt = 0;

    cnt = safe_write(fd,w_buf,len);
    if(cnt == -1)
    {
        fprintf(stderr,"write error!\n");
        return -1;
    }

    return cnt;
}

int uart_close(int fd)
{
    assert(fd);
    close(fd);

    /*可以在這裡做些清理工作*/

    return 0;
}

int main(void)
{
    const char *w_buf = "something to write";
    size_t w_len = sizeof(w_buf);

    char r_buf[1024];
    bzero(r_buf,1024);

    fd = uart_open(fd,"/dev/ttyS0");/*串列埠號/dev/ttySn,USB口號/dev/ttyUSBn*/
    if(fd == -1)
    {
        fprintf(stderr,"uart_open error\n");
        exit(EXIT_FAILURE);
    }

    if(uart_set(fd,9600,0,8,'N',1) == -1)
    {
        fprintf(stderr,"uart set failed!\n");
        exit(EXIT_FAILURE);
    }

    ret = uart_write(fd,w_buf,w_len);
    if(ret == -1)
    {
        fprintf(stderr,"uart write failed!\n");
        exit(EXIT_FAILURE);
    }

    while(1)
    {
        ret = uart_read(fd,r_buf,1024);
        if(ret == -1)
        {
            fprintf(stderr,"uart read failed!\n");
            exit(EXIT_FAILURE);
        }
    }

    ret = uart_close(fd);
    if(ret == -1)
    {
        fprintf(stderr,"uart_close error\n");
        exit(EXIT_FAILURE);
    }

    exit(EXIT_SUCCESS);
}

 

相關推薦

linux串列埠程式設計（termios結構體說明）

termios結構體說明 轉https://www.cnblogs.com/li-hao/archive/2012/02/19/2358158.html termios結構體中，該結構體一般包括如下的成員：tcflag_t       c_iflag;

linux串列埠程式設計（控制流與終端）

流控制 資料在兩個串列埠之間傳輸時，常常會出現丟失資料的現象，或者兩臺計算機的處理速度不同，如桌上型電腦與微控制器之間的通訊，接收端資料緩衝區已滿，則此時繼續傳送來的資料就會丟失。流控制能解決這個問題，當接收端資料處理不過來時，就發出“不再接收”的訊號，傳送端就停止傳送，直到收到“可以繼續傳送”

Linux 串列埠程式設計 使用termios與API進行串列埠程式開發

在 termios 結構體以及內部終端控制標誌中，並非所有的引數對於實際的物理串列埠都是有效的，在使用過程中也不需要對於所有標誌的作用都有所理解。事實上，快速掌握一項技術的核心點也是一種學習能力。對於

Linux串列埠程式設計教程（三）——串列埠程式設計詳（原始碼）解：http://blog.csdn.net/u011192270/article/details/48174353 Linux下的串列埠程式設計(二）----（圖文並茂，講解深刻）http://blog.csdn.net/w28252

Linux串列埠程式設計教程（三）——串列埠程式設計詳（原始碼）解：http://blog.csdn.net/u011192270/article/details/48174353 Linux下的串列埠程式設計(二）----（圖文並茂，講解深刻）http://blog.csdn.ne

Linux串列埠程式設計詳解 linux串列埠相關設定函式

tcgetattr    函式用於獲取與終端相關的引數。引數fd為終端的檔案描述符，返回的結果儲存在termios 結構體中 http://baike.baidu.com/view/5644808.htm?fr=aladdin tcset

Linux串列埠程式設計

串列埠通訊是指一次只傳送一個數據位。雖然在通訊的時候串列埠有 8 位或者 9 位等，但是在物理層面傳輸的時候，它仍然是以單個 bit 的方式傳輸的 一般特指 RS232 標準的介面 在 linux 下串列埠程式設計流程如下： 開啟串列埠 核心是用op

Linux串列埠程式設計詳解

串列埠本身，標準和硬體 † 串列埠是計算機上的序列通訊的物理介面。計算機歷史上，串列埠曾經被廣泛用於連線計算機和終端裝置和各種外部裝置。雖然乙太網介面和USB介面也是以一個序列流進行資料傳送的，但是串列埠連線通常特指那些與RS-232標準相容的硬體或者調變解調器的介面。雖然現在在很

vs2010下mfc的串列埠程式設計（MSComm）

串列埠通訊簡介 　　一般來說，計算機都有一個或多個串列埠，這些串列埠提供了外部裝置與PC進行資料傳輸和通訊的通道，在CPU和外設之間充當直譯器的角色。當字元資料從CPU傳送給外設時，這些字元資料將被轉換成序列位元流資料；當接收資料時，位元流資料被轉換為字元資料傳遞給CPU，再進一步說，在

Linux串列埠程式設計，實現不定長收發資料包

一、需求： 需要利用串列埠對兩臺裝置進行資料互動。 要求：資料包大小不定。能夠實現阻塞讀取每一個數據包。粘包，丟包問題在解析資料包中處理。 二、設計 為了實現不定長接收資料包，利用了 struct termios的兩個成員屬性：  newtio.c_cc

【程式碼參考網上的】linux串列埠程式設計學習筆記

1.串列埠通訊：同步通訊：將很多字元組成一個資訊組進行傳送非同步通訊：一個字元一符的傳送。（可靠性高，但是效率相對降低） 2.通過echo和cat來測試串列埠通訊 echo “Hello” >/dev/ttyS0   cat /dev/ttyS1 3.直接通過read

linux串列埠程式設計說明

1.參考文章1 2.linux手冊參考 3.詳解linux下的串列埠通訊開發 在linux下所有的裝置都是檔案，串列埠也不例外，所以對串列埠的操作也是open,close,write,read這幾個操作，只不過串列埠通訊要想正常溝通，還需要設定正確的屬性。

UART0串列埠程式設計（一）：通訊協議設計；RS232標準

UART0串列埠程式設計（一） 嵌入式系統之間採用通訊方式交換資料，序列通訊是一種最基本的通訊手段。現在由於各類CPU均集成了UART部件。本節對串列埠程式設計時如何設計串列埠通訊協議，以及對RS232介面進行了說明。 1.    通訊協議設計 在進行通訊時，每次需要傳送的

串列埠程式設計（VS2010）

解壓後拷貝到： C:\Windows\System32（WIN7系統）； C:\WINDOWS\system32（XP系統）。 注意：64位win7系統還需要將mscomm32.ocx檔案複製到C:\Windows\SysWOW64\目錄下，否則後面

Android串列埠屏（電阻，電容觸控），帶AV輸入，7寸LCD1（800*48...

基本引數：CPU:MT6572 雙核1GHzRAM：512MB儲存：4GB網路：GSM,WCDMA(BAND1)WIFI:2.4G 802.11bgn藍芽：2.0支援GPS定位 擴充套件引數：1.電源輸入8~28V寬電壓輸入。2.可選配電阻觸控式螢幕和電容觸控式螢幕。3.可選配AV攝像頭輸入，CVBS（

1025 PAT Ranking （25 分）（分組結構體排序）

題目簡單，但是自己暴露了不少小問題。 有一個語法錯誤好坑，卡了好久。 for(int j = 0; j<k; j++){ cin >> arr[++sum].id >> arr[sum].score; arr[sum].local = i;

串列埠通訊（unity，VS通用）

該專案可直接編譯成黑窗體來執行，也可以將程式碼copy到unity中使用。 using System; using System.Collections.Generic; using System.IO; using System.Linq; using System.Text; usi

Android串列埠開發（使用Google開源專案）為什麼建立android_serialport_api的包名

引入： 這個問題就涉及到Android中的NDK開發或者說JAVA中的JNI開發 注：NDK是屬於 Android 的，與Java並無直接關係 正題： 1)，以上問題其實是Android NDK開發生成.so庫後，在其他專案中使用的問題；要想其他直接使用.so庫，

連結串列的應用（資料結構實驗題）

題目：求相鄰k個節點數值之和最大的第一節點 輸入資料（設為整型）建立單鏈表，並求相鄰k個節點data值之和為最大的第一節點。例如輸入k = 2，資料為2 6 4 7 3 #（#為結束符），建立下面連結串列，執行結果輸出（序號3，data值4）： 一、

Unity之串列埠通訊（基於三姿態感測器）

/*******************************/ using UnityEngine; using System.Collections; //Other libraries using System; using System.Threading; using System.Collect

Linux高效能服務程式設計（I/O複用）

I/O複用（本身是阻塞的）網路程式需要使用I/O複用技術的情況：1.客戶端程式需要同時處理多個socket。2.客戶端需要同時處理使用者輸入和網路連線3.TCP伺服器要同時處理監聽socket和連線socket4.伺服器要同時處理TCP請求和UDP請求5.伺服器要同時監聽多個