串行口是計算機一種常用的接口，具有連接線少，通訊簡單，得到廣泛的使用。常用的串口是RS-232-C接口(又稱EIA RS-232-C)它是在1970年由美國電子工業協會(EIA)聯合貝爾系統、調制解調器廠家及計算機終端生產廠家共同制定的用於串行通訊的標準。它的全名是"數據終端設備(DTE)和數據通訊設備(DCE)之間串行二進制數據交換接口技術標準"該標準規定採用一個25個腳的DB25連接器，對連接器的每個引腳的信號內容加以規定，還對各種信號的電平加以規定。傳輸距離在碼元畸變小於4%的情況下，傳輸電纜長度應爲50英尺。

在linux文件中，所有的設備文件一般都位於/dev下，其中串口一、串口二分別對應的設備名依次爲“/dev/ttyS0”、“/dev/ttyS1”，可以查看在/dev下的文件以確認。在linux下面對於串口的讀寫就可以通過簡單的read、write函數來完成，所不同的是隻是需要對串口的其他參數另坐配置。

1. 串口編程需要用到的頭文件

#include <stdio.h> // 標準輸入輸出定義

#include <stdlib.h>

#include <fcntl.h> // 文件控制定義，主要完成串口通信中對文件的讀寫操作

#include <unistd.h> // linux標準函數定義

#include <sys/ioctl.h>

#include <termios.h> // POSIX終端控制定義

#include <sys/time.h>

#include <sys/types.h>

2. 串口終端函數

2.1 打開串口設備

int fd；

char *device = "/dev/tts/0"; // 設備路徑，初始使用UART0

for(t=1;t<argc;t++) // 獲取程序入口時輸入的參數

{

if(!strcmp(argv[t],"-d") && (argc > (t+1)))

{

device = argv[t+1];

}

if(!strcmp(device,"/dev/tts/1")) // 不允許使用UART1，因爲它已和PC相連。

{

printf("can not use /dev/tts/1\n");

return -1;

}

fd = open(device, O_RDWR); // 打開設備

if (fd < 0) // 設備打開失敗

{

printf("open device error\n");

return -1;

}

2.2 設置串口

最基本的串口設置包括波特率設置，校驗位和停止位設置。實際上串口的設置只要是設置Struct termios（）結構體中各成員的值。

struct termio

{ unsigned short c_iflag; /* 輸入模式標誌 */

unsigned short c_oflag; /* 輸出模式標誌 */

unsigned short c_cflag; /* 控制模式標誌*/

unsigned short c_lflag; /* local mode flags */

unsigned char c_line; /* line discipline */

unsigned char c_cc[NCC]; /* control characters */

};

2.2.1 波特率設置

struct termios Opt;

tcgetattr(fd, &Opt); // 得到當前串口的參數

cfsetispeed(&Opt,B19200); /*設置爲19200Bps*/

cfsetospeed(&Opt,B19200);

tcsetattr(fd,TCANOW,&Opt); // 激活新配置

設置波特率的例子函數：

/**

*@brief 設置串口通信速率

*@param fd 類型 int 打開串口的文件句柄

*@param speed 類型 int 串口速度

*@return void

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(fd1, TCSANOW, &Opt);

if (status != 0) {

perror("tcsetattr fd1");

return;

}

tcflush(fd,TCIOFLUSH);

}

2.2.2 校驗位和停止位設置

/**

*@brief 設置串口數據位，停止位和效驗位

*@param fd 類型 int 打開的串口文件句柄

*@param databits 類型 int 數據位取值爲 7 或者8

*@param stopbits 類型 int 停止位取值爲 1 或者2

*@param parity 類型 int 效驗類型取值爲N,E,O,,S

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 */

break;

case 'o':

case 'O':

options.c_cflag |= (PARODD | PARENB); /* 設置爲奇效驗*/

options.c_iflag |= INPCK; // INPCK:奇偶校驗使能

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': // Space 校驗

case 's': /*as no parity*/

options.c_cflag &= ~PARENB;

options.c_cflag &= ~CSTOPB;

options.c_iflag |= INPCK;

break;

default:

fprintf(stderr,"Unsupported parity\n");

return (FALSE);

}

// 設置停止位

switch (stopbits)

{

case 1:

options.c_cflag &= ~CSTOPB; // 1個停止位

break;

case 2:

options.c_cflag |= CSTOPB; // 2個停止位

break;

default:

fprintf(stderr,"Unsupported stop bits\n");

return (FALSE);

}

// 處理未接收的字符

tcflush(fd,TCIFLUSH);

// 設置等待時間和最小接收字符

options.c_cc[VTIME] = 150; /* 設置超時15 seconds*/

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);

}

2.2.3 模式設置

需要注意的是，如果不是開發終端之類的，只是串口傳輸數據，而不需要串口來處理，那麼使用原始模式（Raw Mode）方式來通信。

newtio.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); // 原始數據輸入

newtio.c_oflag &= ~(OPOST); // 原始數據輸出

2.2.4 串口配置實例

void init_ttyS(int fd)

{

struct termios newtio;

bzero(&newtio, sizeof(newtio));

// 得到當前串口的參數

tcgetattr(fd, &newtio);

// 將輸入波特率設爲19200

// 將輸出波特率設爲19200

cfsetispeed(&newtio, B19200);

cfsetospeed(&newtio, B19200);

// 使能接收並使能本地狀態

newtio.c_cflag |= (CLOCAL | CREAD);

// 無校驗 8位數據位1位停止位

newtio.c_cflag &= ~PARENB;

newtio.c_cflag &= ~CSTOPB;

newtio.c_cflag &= ~CSIZE;

// 8個數據位

newtio.c_cflag |= CS8;

// 原始數據輸入

newtio.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);

newtio.c_oflag &= ~(OPOST);

// 設置等待時間和最小接收字符數

newtio.c_cc[VTIME] = 0;

newtio.c_cc[VMIN] = 0;

// 處理未接收的字符

tcflush(fd, TCIFLUSH);

// 激活新配置

tcsetattr(fd,TCSANOW,&newtio);

}

2.1 讀串口

讀取串口數據使用文件操作read函數讀取，如果設置爲原始模式(Raw Mode)傳輸數據，那麼read函數返回的字符數是實際串口收到的字符數。

char buff[1024];

int Len;

int readByte = read(fd,buff,Len);

可以使用操作文件的函數來實現異步讀取，如fcntl，或者select等來操作。

void SERIAL_RX(void)

{

// read(fd, RXBUF , RX_len);

#if 1

int ret,n,pos,retval;

fd_set rfds;

struct timeval tv ;

pos = 0;//指向接收緩衝

for(n = 0; n < RX_len; n++)

{

RXBUF[n] = 0xFF;

}

FD_ZERO(&rfds);// 清空串口接收端口集

FD_SET(fd,&rfds);// 設置串口接收端口集

tv.tv_sec = 2;

tv.tv_usec = 0;

while(FD_ISSET(fd,& rfds)) // 檢測串口是否有讀寫動作

{

// 每次循環都要清空，否則不會檢測到有變化

FD_ZERO(&rfds);// 清空串口接收端口集

FD_SET(fd,&rfds);// 設置串口接收端口集

retval = select(fd+1,&rfds,NULL,NULL,&tv);

if(retval == -1)

{

perror("select()");

break;

}

else if(retval)

{ //判斷是否還有數據

//sleep(2);

ret = read(fd, RXBUF, RX_len);

pos += ret;

//printf("ret = %d \n",ret);

if((RXBUF[pos-2] == '\r') & (RXBUF[pos-1] == '\n')) // 確實接收到了數據，並打印出來

{

FD_ZERO(&rfds);

FD_SET(fd,&rfds);

retval = select(fd+1,&rfds,NULL,NULL,&tv);

if(!retval)//no datas

{

break;

}

else

{

break;

}

Linux下直接用read讀串口可能會造成堵塞，或數據讀出錯誤。然而用select先查詢com口，再用read去讀就可以避免，並且當com口延時時，程序可以退出，這樣就不至於由於com口堵塞，程序就死了。

Select的函數格式(我所說的是Unix系統下的伯克利socket編程，和windows下的有區別，一會兒說明)：

int select(int maxfdp,fd_set *readfds,fd_set *writefds,fd_set *errorfds,struct timeval *timeout);

先說明兩個結構體：

l struct fd_set

可以理解爲一個集合，這個集合中存放的是文件描述符(file descriptor)，即文件句柄，這可以是我們所說的普通意義的文件，當然Unix下任何設備、管道、FIFO等都是文件形式，全部包括在內，所以毫無疑問一個socket就是一個文件，socket句柄就是一個文件描述符。fd_set集合可以通過一些宏由人爲來操作，比如：

? FD_ZERO(fd_set *set):清除一個文件描述符集；

? FD_SET(int fd, fd_set *set):將一個文件描述符加入文件描述符集中；

? FD_CLR(int fd, fd_set *set):將一個文件描述符從文件描述符集中清除；

? FD_ISSET(int fd, fd_set *set): 檢查集合中指定的文件描述符是否可以讀寫。

一會兒舉例說明。

l struct timeval

是一個大家常用的結構，用來代表時間值，有兩個成員，一個是秒數，另一個是毫秒數。

struct timeval{

long tv_sec;

long tv_unsec;

}

具體解釋select的參數：

l int maxfdp

是一個整數值，是指集合中所有文件描述符的範圍，即所有文件描述符的最大值加1，不能錯！在Windows中這個參數的值無所謂，可以設置不正確。

l fd_set *readfds

是指向fd_set結構的指針，這個集合中應該包括文件描述符，我們是要監視這些文件描述符的讀變化的，即我們關心是否可以從這些文件中讀取數據了，如果這個集合中有一個文件可讀，select就會返回一個大於0的值，表示有文件可讀，如果沒有可讀的文件，則根據timeout參數再判斷是否超時，若超出timeout的時間，select返回0，若發生錯誤返回負值。可以傳入NULL值，表示不關心任何文件的讀變化。

l fd_set *writefds

是指向fd_set結構的指針，這個集合中應該包括文件描述符，我們是要監視這些文件描述符的寫變化的，即我們關心是否可以向這些文件中寫入數據了，如果這個集合中有一個文件可寫，select就會返回一個大於0的值，表示有文件可寫，如果沒有可寫的文件，則根據timeout參數再判斷是否超時，若超出timeout的時間，select返回0，若發生錯誤返回負值。可以傳入NULL值，表示不關心任何文件的寫變化。

l fd_set *errorfds

同上面兩個參數的意圖，用來監視文件錯誤異常。

l struct timeval* timeout

是select的超時時間，這個參數至關重要，它可以使select處於三種狀態，第一，若將NULL以形參傳入，即不傳入時間結構，就是將select置於阻塞狀態，一定等到監視文件描述符集合中某個文件描述符發生變化爲止；第二，若將時間值設爲0秒0毫秒，就變成一個純粹的非阻塞函數，不管文件描述符是否有變化，都立刻返回繼續執行，文件無變化返回0，有變化返回一個正值；第三，timeout的值大於0，這就是等待的超時時間，即select在timeout時間內阻塞，超時時間之內有事件到來就返回了，否則在超時後不管怎樣一定返回，返回值同上述。

l 返回值：

負值：select錯誤正值：某些文件可讀寫或出錯 0：等待超時，沒有可讀寫或錯誤的文件

在有了select後可以寫出像樣的網絡程序來！舉個簡單的例子，就是從網絡上接受數據寫入一個文件中。

一般來說，在使用select函數之前，首先使用FD_ZERO和FD_SET來初始化文件描述符集，在使用了select函數時，可循環使用FD_ISSET測試描述符集，在執行完對相關的文件描述符後，使用FD_CLR來清除描述符集。

2.2 寫串口

讀寫串口設置好串口之後，讀寫串口就很容易了，把串口當作文件讀寫就是。發送數據:

char buffer[1024];

int Length;

int nByte;

nByte = write(fd, buffer ,Length);

2.3 關閉串口

close（fd）；

3. 具體應用實例

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <fcntl.h>

#include <unistd.h>

#include <sys/ioctl.h>

#include<time.h>

#include <termios.h>

#include <sys/select.h>

#include <sys/types.h>

//#include "COMM.h"

#define ACK_SUCCESS 0x00 // 操作成功

#define ACK_FAIL 0x01 // 操作失敗

#define ACK_FULL 0x04 // Full

#define ACK_NOUSER 0x05 // 無此用戶

#define ACK_USER_EXIST 0x07 // 用戶已存在

#define ACK_TIMEOUT 0x08 // 採集超時

#define ACK_COUNT 0x3 //發生錯誤時候，重試次數

extern unsigned char TXBUF[9900];

extern unsigned char RXBUF[9900];

extern unsigned char rev_ok;

extern unsigned int TX_len;

extern unsigned int RX_len;

extern unsigned char one_onecontrast(unsigned char user_number_h,unsigned char user_number_l);

extern unsigned char one_morecontrast(void);

extern unsigned char Get_UserNumber_Right(void);

extern unsigned char set_addmode(unsigned char yn_repeat);

extern unsigned char add_Fingerprint(unsigned char time_number,unsigned char user_number_h,

unsigned char user_number_l,unsigned char user_right);

extern unsigned char del_alluser(void);

extern unsigned char del_oneuser(unsigned char user_number_h,unsigned char user_number_l);

extern unsigned char read_usernumber(void);

int fd;

unsigned char USER_NUMBER_H; // 用戶號高8位

unsigned char USER_NUMBER_L; // 用戶號低8位

unsigned char USER_RIGHT; // 用戶權限

unsigned char FEATURE_BUFFER[512]; // 要下傳的指紋特徵值數據

unsigned char FEATURE_LEN; // 要下傳的指紋特徵值的長度

unsigned char CharToHex(unsigned char ch);

unsigned char select_one_onecontrast(void);

void select_Get_Usernumber_right(void);

/*********************************************************************************************

* name: SERIAL_TX

* func: 發生數據到指紋模塊串口

* para: none

* ret: none

* modify:

* comment:

*********************************************************************************************/

int SERIAL_TX(void)

{

int ret;

ret = write(fd, TXBUF, TX_len); // 試圖從串口發送數據

if(ret == -1) // 確實接收到了數據，並打印出來

{

// *(rcv_buf+ret)='\0';

printf(" Write device error!\n");

return -1;

// ret = 0;

}

return 0;

}

/*********************************************************************************************

* name: SERIAL_RX

* func: 從指紋模塊串口接收數據

* para: none

* ret: none

* modify:

* comment:

*********************************************************************************************/

void SERIAL_RX(void)

{

// read(fd, RXBUF , RX_len);

#if 1

int ret,n,pos,retval;

fd_set rfds;

struct timeval tv ;

pos = 0;//指向接收緩衝

tv.tv_sec = 2;

tv.tv_usec = 0;

for(n = 0; n < RX_len; n++)

{

RXBUF[n] = 0xFF;

}

//while(FD_ISSET(fd,&uart_r)||FD_ISSET(fd,&uart_w)); // 檢測串口是否有讀寫動作

while(1) // 檢測串口是否有讀寫動作

{

FD_ZERO(&rfds);// 清空串口接收端口集

FD_SET(fd,&rfds);// 設置串口接收端口集

retval = select(fd+1,&rfds,NULL,NULL,&tv);

if(retval == -1)

{

perror("select()");

break;

}

else if(retval)

{ //判斷是否還有數據

//sleep(2);

ret = read(fd, RXBUF, RX_len);

pos += ret;

//printf("ret = %d \n",ret);

if((RXBUF[pos-2] == '\r') & (RXBUF[pos-1] == '\n')) // 確實接收到了數據，並打印出來

{

FD_ZERO(&rfds);

FD_SET(fd,&rfds);

retval = select(fd+1,&rfds,NULL,NULL,&tv);

if(!retval)//no datas

{

break;

}

else

{

break;

}

void init_ttyS(int fd)

{

struct termios newtio;

bzero(&newtio, sizeof(newtio));

tcgetattr(fd, &newtio); // 得到當前串口的參數

cfsetispeed(&newtio, B19200); // 將輸入波特率設爲19200

cfsetospeed(&newtio, B19200); // 將輸出波特率設爲19200

newtio.c_cflag |= (CLOCAL | CREAD); // 使能接收並使能本地狀態

newtio.c_cflag &= ~PARENB; // 無校驗 8位數據位1位停止位

newtio.c_cflag &= ~CSTOPB;

newtio.c_cflag &= ~CSIZE;

newtio.c_cflag |= CS8;

newtio.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); // 原始數據輸入

newtio.c_oflag &= ~(OPOST);

newtio.c_cc[VTIME] = 0; // 設置等待時間和最小接收字符數

newtio.c_cc[VMIN] = 0;

tcflush(fd, TCIFLUSH); // 處理未接收的字符

tcsetattr(fd,TCSANOW,&newtio); // 激活新配置

}

unsigned char set_addmode(unsigned char yn_repeat)

{

unsigned char check, i;

TXBUF[0] = 0xF5;

TXBUF[1] = 0x2D;

TXBUF[2] = 0x00;

TXBUF[3] = yn_repeat;

TXBUF[4] = 0x00;

TXBUF[5] = 0x00;

check = TXBUF[1];

for (i = 2; i < 6; i++)

{

check ^= TXBUF[i];

}

TXBUF[6] = check;

TXBUF[7] = 0xF5;

rev_ok = 1;

TX_len = 8;

RX_len = 8;

SERIAL_TX();

sleep(delaytime);

SERIAL_RX();

rev_ok = RXBUF[4];

return (rev_ok);

}

int main(int argc, char ** argv)

{

int t,ret;

char mode;

char *device = "/dev/tts/0"; // 設備路徑，初始使用UART0

for(t=1;t<argc;t++) // 獲取程序入口時輸入的參數

{

if(!strcmp(argv[t],"-d") && (argc > (t+1)))

{

device = argv[t+1];

}

if(!strcmp(device,"/dev/tts/1")) // 不允許使用UART1，因爲它已和PC相連。

{

printf("can not use /dev/tts/1\n");

return -1;

}

fd = open(device, O_RDWR); // 打開設備

if (fd < 0) // 設備打開失敗

{

printf("open device error\n");

return -1;

}

init_ttyS(fd); // 初始化設備

while(1)

{

set_addmode(1); // 設置指紋添加模式，禁止重複

}

close(fd); // 關閉打開的設備

return 0; // 正常返回

}

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------2-----------------------------------------------------------------------------------------------------------------------------------

據通信的基本方式可分爲並行通信與串行通信兩種。
· 並行通信是指利用多條數據傳輸線將一個資料的各位同時傳送。它的特點是傳輸速度
快，適用於短距離通信，但要求傳輸速度較高的應用場合。
· 串行通信是指利用一條傳輸線將資料一位位地順序傳送。特點是通信線路簡單，利用
簡單的線纜就可實現通信，降低成本，適用於遠距離通信，但傳輸速度慢的應用場合。
串口設置詳解
本節主要講解設置串口的主要方法。
如前所述，設置串口中最基本的包括波特率設置，校驗位和停止位設置。串口的設置主
要是設置struct termios結構體的各成員值，如下所示：
＃include
struct termio
{
      unsigned short c_iflag; /* 輸入模式標誌 */
      unsigned short c_oflag; /* 輸出模式標誌 */
      unsigned short c_cflag; /* 控制模式標誌*/
      unsigned short c_lflag; /*本地模式標誌 */
      unsigned char c_line; /* line discipline */
      unsigned char c_cc[NCC]; /* control characters */
};
在這個結構中最爲重要的是c_cflag，通過對它的賦值，用戶可以設置波特率、字符大小、
數據位、停止位、奇偶校驗位和硬件流控等。另外c_iflag 和c_cc 也是比較常用的標誌。在
此主要對這3 個成員進行詳細說明。
                 c_cflag支持的常量名稱
CBAUD        波特率的位掩碼
B0           0波特率（放棄DTR）
B1800        1800波特率
B2400        2400波特率
B4800        4800波特率
B9600        9600波特率
B19200       19200波特率
B38400       38400波特率
B57600       57600波特率
B115200      115200波特率
EXTA         外部時鐘率
EXTB         外部時鐘率
CSIZE        數據位的位掩碼
CS5          5個數據位
CS6          6個數據位
CS7          7個數據位
CS8          8個數據位
CSTOPB       2個停止位（不設則是1個停止位）
CREAD        接收使能
PARENB       校驗位使能
PARODD       使用奇校驗而不使用偶校驗
HUPCL        最後關閉時掛線（放棄DTR）
CLOCAL       本地連接（不改變端口所有者）
LOBLK        塊作業控制輸出
CNET_CTSRTS 硬件流控制使能

      c_iflag支持的常量名稱
INPCK        奇偶校驗使能
IGNPAR       忽略奇偶校驗錯誤
PARMRK       奇偶校驗錯誤掩碼
ISTRIP       除去奇偶校驗位
IXON         啓動出口硬件流控
IXOFF        啓動入口軟件流控
IXANY        允許字符重新啓動流控
IGNBRK       忽略中斷情況
BRKINT       當發生中斷時發送SIGINT信號
INLCR        將NL映射到CR
IGNCR        忽略CR
ICRNL        將CR映射到NL
IUCLC        將高位情況映射到低位情況
IMAXBEL      當輸入太長時回覆ECHO
      c_cc 支持的常量名稱
VINTR     中斷控制，對應鍵爲CTRL+C
VQUIT     退出操作，對應鍵爲CRTL+Z
VERASE    刪除操作，對應鍵爲Backspace（BS）
VKILL     刪除行，對應鍵爲CTRL+U
VEOF      位於文件結尾，對應鍵爲CTRL+D
VEOL      位於行尾，對應鍵爲Carriage return（CR）
VEOL2     位於第二行尾，對應鍵爲Line feed（LF）
VMIN      指定了最少讀取的字符數
VTIME     指定了讀取每個字符的等待時間

串口控制函數
Tcgetattr         取屬性(termios結構)
Tcsetattr         設置屬性(termios結構)
cfgetispeed     得到輸入速度
Cfgetospeed           得到輸出速度
Cfsetispeed            設置輸入速度
Cfsetospeed           設置輸出速度
Tcdrain           等待所有輸出都被傳輸
tcflow           掛起傳輸或接收
tcflush           刷清未決輸入和/或輸出
Tcsendbreak           送BREAK字符
tcgetpgrp              得到前臺進程組ID
tcsetpgrp               設置前臺進程組ID

[color=#ff0000]完整的串口配置模板，實用！把常用的選項在函數裏面列出，可大大方便用戶的調試使用[/color]

int set_opt(int fd,int nSpeed, int nBits, char nEvent, int nStop)
{
    struct termios newtio,oldtio;
    /*保存測試現有串口參數設置，在這裏如果串口號等出錯，會有相關的出錯信息*/
    if ( tcgetattr( fd,&oldtio) != 0)
    {
        perror("SetupSerial 1");
         return -1;
     }
    bzero( &newtio, sizeof( newtio ) );
    /*步驟一，設置字符大小*/
    newtio.c_cflag |= CLOCAL | CREAD;
    newtio.c_cflag &= ~CSIZE;
    /*設置停止位*/
    switch( nBits )
    {
        case 7:
            newtio.c_cflag |= CS7;
            break;
        case 8:
            newtio.c_cflag |= CS8;
            break;
    }
/*設置奇偶校驗位*/
    switch( nEvent )
    {
        case 'O': //奇數
            newtio.c_cflag |= PARENB;
            newtio.c_cflag |= PARODD;
            newtio.c_iflag |= (INPCK | ISTRIP);
        break;
        case 'E': //偶數
            newtio.c_iflag |= (INPCK | ISTRIP);
            newtio.c_cflag |= PARENB;
            newtio.c_cflag &= ~PARODD;
        break;
            case 'N': //無奇偶校驗位
            newtio.c_cflag &= ~PARENB;
        break;
    }
    /*設置波特率*/
    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 115200:
            cfsetispeed(&newtio, B115200);
            cfsetospeed(&newtio, B115200);
        break;
        case 460800:
            cfsetispeed(&newtio, B460800);
            cfsetospeed(&newtio, B460800);
        break;
        default:
            cfsetispeed(&newtio, B9600);
            cfsetospeed(&newtio, B9600);
        break;
    }
    /*設置停止位*/
    if( nStop == 1 )
        newtio.c_cflag &= ~CSTOPB;
    else if ( nStop == 2 )
        newtio.c_cflag |= CSTOPB;
    /*設置等待時間和最小接收字符*/
    newtio.c_cc[VTIME] = 0;
    newtio.c_cc[VMIN] = 0;
    /*處理未接收字符*/
    tcflush(fd,TCIFLUSH);
    /*激活新配置*/
    if((tcsetattr(fd,TCSANOW,&newtio))!=0)
    {
        perror("com set error");
        return -1;
    }
    printf("set done!\n");
    return 0;
}

[b]串口使用詳解[/b]
在配置完串口的相關屬性後，就可對串口進行打開，讀寫操作了。其使用方式與文件操作一樣，區別在於串口是一個終端設備。

[b]打開串口[/b]
fd = open( "/dev/ttyS0", O_RDWR|O_NOCTTY|O_NDELAY);

   Open函數中除普通參數外，另有兩個參數O_NOCTTY和O_NDELAY。
   O_NOCTTY: 通知linix系統，這個程序不會成爲這個端口的控制終端。
   O_NDELAY: 通知linux系統不關心DCD信號線所處的狀態（端口的另一端是否激活或者停止）。
然後，恢復串口的狀態爲阻塞狀態，用於等待串口數據的讀入。用fcntl函數：
       fcntl（fd, F_SETFL, 0）;

   接着，測試打開的文件描述府是否引用一個終端設備，以進一步確認串口是否正確打開。
       isatty(STDIN_FILENO);
串口的讀寫與普通文件一樣，使用read,write函數。
       read(fd,buff,8);
       write(fd,buff,8);
實例

＃i nclude stdio.h>
＃i nclude string.h>
＃i nclude sys/types.h>
＃i nclude errno.h>
＃i nclude sys/stat.h>
＃i nclude fcntl.h>
＃i nclude unistd.h>
＃i nclude termios.h>
＃i nclude stdlib.h>
int set_opt(int fd,int nSpeed, int nBits, char nEvent, int nStop)
{
    struct termios newtio,oldtio;
    if ( tcgetattr( fd,&oldtio) != 0) {
        perror("SetupSerial 1");
        return -1;
    }
    bzero( &newtio, sizeof( newtio ) );
    newtio.c_cflag |= CLOCAL | CREAD;
    newtio.c_cflag &= ~CSIZE;
    switch( nBits )
    {
    case 7:
        newtio.c_cflag |= CS7;
        break;
    case 8:
        newtio.c_cflag |= CS8;
        break;
    }
    switch( nEvent )
    {
    case 'O':
        newtio.c_cflag |= PARENB;
        newtio.c_cflag |= PARODD;
        newtio.c_iflag |= (INPCK | ISTRIP);
        break;
    case 'E':
        newtio.c_iflag |= (INPCK | ISTRIP);
        newtio.c_cflag |= PARENB;
        newtio.c_cflag &= ~PARODD;
        break;
    case 'N':
        newtio.c_cflag &= ~PARENB;
        break;
    }
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 115200:
        cfsetispeed(&newtio, B115200);
        cfsetospeed(&newtio, B115200);
        break;
    default:
        cfsetispeed(&newtio, B9600);
        cfsetospeed(&newtio, B9600);
        break;
    }
    if( nStop == 1 )
        newtio.c_cflag &= ~CSTOPB;
    else if ( nStop == 2 )
    newtio.c_cflag |= CSTOPB;
    newtio.c_cc[VTIME] = 0;
    newtio.c_cc[VMIN] = 0;
    tcflush(fd,TCIFLUSH);
    if((tcsetattr(fd,TCSANOW,&newtio))!=0)
    {
        perror("com set error");
        return -1;
    }
    printf("set done!\n");
    return 0;
}
int open_port(int fd,int comport)
{
    char *dev[]={"/dev/ttyS0","/dev/ttyS1","/dev/ttyS2"};
    long vdisable;
    if (comport==1)
    {    fd = open( "/dev/ttyS0", O_RDWR|O_NOCTTY|O_NDELAY);
        if (-1 == fd){
            perror("Can't Open Serial Port");
            return(-1);
        }
        else
            printf("open ttyS0 .....\n");
    }
    else if(comport==2)
    {    fd = open( "/dev/ttyS1", O_RDWR|O_NOCTTY|O_NDELAY);
        if (-1 == fd){
            perror("Can't Open Serial Port");
            return(-1);
        }
        else
            printf("open ttyS1 .....\n");
    }
    else if (comport==3)
    {
        fd = open( "/dev/ttyS2", O_RDWR|O_NOCTTY|O_NDELAY);
        if (-1 == fd){
            perror("Can't Open Serial Port");
            return(-1);
        }
        else
            printf("open ttyS2 .....\n");
    }
    if(fcntl(fd, F_SETFL, 0)0)
        printf("fcntl failed!\n");
    else
        printf("fcntl=%d\n",fcntl(fd, F_SETFL,0));
    if(isatty(STDIN_FILENO)==0)
        printf("standard input is not a terminal device\n");
    else
        printf("isatty success!\n");
    printf("fd-open=%d\n",fd);
    return fd;
}
int main(void)
{
    int fd;
    int nread,i;
    char buff[]="Hello\n";
    if((fd=open_port(fd,1))0){
        perror("open_port error");
        return;
    }
    if((i=set_opt(fd,115200,8,'N',1))0){
        perror("set_opt error");
        return;
    }
    printf("fd=%d\n",fd);
//    fd=3;
    nread=read(fd,buff,8);
    printf("nread=%d,%s\n",nread,buff);
    close(fd);
    return;

}

jack_bro

發佈了8 篇原創文章 · 獲贊 4 · 訪問量 3萬+

私信關注

linux串口編程

1. 串口編程需要用到的頭文件

2. 串口終端函數

2.1 打開串口設備

2.2 設置串口

2.2.1 波特率設置

2.2.2 校驗位和停止位設置

2.2.3 模式設置

2.2.4 串口配置實例

2.1 讀串口

2.2 寫串口

2.3 關閉串口

3. 具體應用實例

從報文格式分析OSI 7層協議

Linux下串口編程，解決數據接收0x0D自動轉換成0x0A

uart 使用軟流控

linux串口編程

QT中顯示GIF圖片

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結