UNIX再学习 -- RS485 串口编程

这部分本该放到 linux 下才讲的,但是讲到 select 就不得不提到了串口通信。

参看:UNIX再学习 -- 函数 select、poll、epoll 

那也简单了直接将之前的写好的文章,加以总结吧。


最近被安排实现 linux rs485 串口通信。期间遇到各种问题,现在加以分析总结。

一、硬件相关 

1.1 单工、半双工、全双工

首先,我使用的是芯片为 SP3485E 为半双工通信。那么先要明确什么是单工、半双工、全双工。
单工数据传输只支持数据在一个方向上传输;
半双工数据传输允许数据在两个方向上传输
,但是,在某一时刻,只允许数据在一个方向上传输,它实际上是一种切换方向的单工通信;
全双工数据通信允许数据同时在两个方向上传输,因此,全双工通信是两个单工通信方式的结合,它要求发送设备和接收设备都有独立的接收和发送能力。 
网卡的全双工(Full Duplex)是指网卡在发送数据的同时也能够接收数据,两者同步进行,这好像我们平时打电话一样,说话的同时也能够听到对方的声音。目前的网卡一般都支持全双工。


提到全双工,就不能不提与之密切对应的另一个概念,那就是“半双工(Half Duplex)”,
所谓半双工就是指一个时间段内只有一个动作发生,举个简单例子,一条窄窄的马路,同时只能有一辆车通过,
当目前有两量车对开,这种情况下就只能一辆先过,等到头儿后另一辆再开,这个例子就形象的说明了半双工的原理。早期的对讲机、以及早期集线器等设备都是基于半双工的产品。随着技术的不断进步,半双工会逐渐退出历史舞台。

1.2 关于RS485通信

RS232 标准是诞生于 RS485 之前的,但是 RS232 有几处不足的地方:
接口的信号电平值较高,
达到十几 V,使用不当容易损坏接口芯片,电平标准也与TTL 电平不兼容。
传输速率有局限,不可以过高,一般到一两百千比特每秒(Kb/s)就到极限了。
接口使用信号线和 GND 与其它设备形成共地模式的通信,这种共地模式传输容易产生干扰,并且抗干扰性能也比较弱。
传输距离有限,最多只能通信几十米。
通信的时候只能两点之间进行通信,不能够实现多机联网通信。

针对 RS232 接口的不足,就不断出现了一些新的接口标准,RS485 就是其中之一,它具备以下的特点
采用差分信号。我们在讲 A/D 的时候,讲过差分信号输入的概念,同时也介绍了差分输入的好处,最大的优势是可以抑制共模干扰。
尤其当工业现场环境比较复杂,干扰比较多时,采用差分方式可以有效的提高通信可靠性。RS485 采用两根通信线,通常用 A 和 B 或者 D+和 D-来表示。逻辑“1”以两线之间的电压差为+(0.2~6)V 表示,逻辑“0”以两线间的电压差为-(0.2~6)V 来表示,是一种典型的差分通信。
RS485 通信速率快
,最大传输速度可以达到 10Mb/s 以上。
RS485 内部的物理结构,采用的是平衡驱动器和差分接收器的组合,抗干扰能力也大大增加
传输距离最远可以达到 1200 米左右,但是它的传输速率和传输距离是成反比的,只有在 100Kb/s 以下的传输速度,才能达到最大的通信距离,如果需要传输更远距离可以使用中继。
可以在总线上进行联网实现多机通信,总线上允许挂多个收发器,从现有的 RS485芯片来看,有可以挂 32、64、128、256 等不同个设备的驱动器。
RS485 的接口非常简单,与 RS232 所使用的 MAX232 是类似的,只需要一个 RS485转换器,就可以直接与单片机的 UART 串口连接起来,并且使用完全相同的异步串行通信协议。
但是由于 RS485 是差分通信,因此接收数据和发送数据是不能同时进行的,也就是说它是一种半双工通信。RS485为差分通信:最大的优势是可以抑制共模干扰。

1.3  关于sp3485硬件分析


                                                                上图为SP3485原理图 

(1)引脚说明: 

Pin1 - RO: 接收器输出

Pin2 - RE#:接收器输出使能 (低电平有效)

Pin3 - DE: 驱动器输出使能 (高电平有效)

Pin4 - DI: 驱动器输入

Pin5 - GND: 连接地

Pin6 - A: 驱动器输出/接收器输入 (同相)

Pin7 - B: 驱动器输出/接收器输入 (反相)

Pin8 - Vcc       

注意将AB间120欧姆去掉,如果采用阻抗匹配的电缆,300米以内几乎可以不用加终端电阻。加终端电阻的缺点就是增大了线路的无用功耗,尤其是电池系统供电时,降低了电池的续航能力。

PS: 我一开始没有将它去掉,导致只能发送数据,无法接收数据。

(2)电气特性

RS-232电平电气特性

EIA电平(串口)

逻辑1:-3V~-15V

逻辑0:+3V~+15V


TTL电平(TPAD)

逻辑1:+2V~+5V

逻辑0:+0V~+0.8V


接收数据:EIA->TTL  232转TTL

发送数据:TTL->EIA  TTL转232

 

串口异步通信的重要参数:

波特率: bps (bit per second)

数据位的个数: 5 6 7 8

校验方式: 奇校验 偶校验 无校验

停止位: 1bit  2bit


RS485电平 和RS422电平 由于两者均采用 差分传输(平衡传输)的方式,所以他们的电平方式,一般有两个引脚 A,B

发送端 AB间的电压差

+2 ~ +6v 1

-2 ~ -6v   0

接收端 AB间的电压差

大于 +200mv   1

小于 -200mv 0


定义逻辑1为B>A的状态

定义逻辑0为A>B的状态

AB之间的电压差不小于200mv


一对一的接头的情况下:

RS232 可做到双向传输,全双工通讯   最高传输速率 20kbps

422    只能做到单向传输,半双工通讯,最高传输速率10Mbps

485    双向传输,半双工通讯, 最高传输速率10Mbps

(3)串行数据的格式

异步串行数据的一般格式是:起始位+数据位+停止位,(8-N-1格式) 其中起始位1 位,数据位可以是5、6、7、8位,停止位可以是1、1.5、2位。

起始位是一个值为0的位,所以对于正逻辑的TTL电平,起始位是一位时间的低电平;停止位是值为1的位,所以对于正逻辑的TTL电平,停止位是高电平。线路路空闲或者数据传输结束,对于正逻辑的TTL电平,线路总是1。对于负逻辑(如RS-232电平)则相反。

例如,对于16进制数据55aaH,当采用8位数据位、1位停止位传输时,它在信号线上的波形如图1(TTL电平)和图2(RS-232电平)所示。 (先传第一个字节55,再传第二个字节aa,每个字节都是从低位向高位逐位传输)


                   图1 TTL电平的串行数据帧格式(55aah)


                    图2 RS-232电平的串行数据帧格式(55aah)

(4)根据波形图计算波特率

如图3是图1在示波器中的显示示意,其中灰色线是示波器的时间分度线,此时假设是200us/格。

                     图3 波特率计算示意图

可以看了,第一个字节的10位(1位起始位,8位数据位和1位停止位)共占约1.05ms,这样可计算出其波特率约为:

10bit / 1.05ms X 1000 ≈ 9600 bit/s

如果上图中的时间轴是100us/格,同样可以计算出波特率应是19200bit/s。

当通讯不正常,又能观察到波形时,就可根据上述方法,从波形图计算一下波特率是否正确。

(5)根据波形图判断RS-485收发数据的正确与否

RS-485是一种半双工的串行通讯方式(RS-422为全双工),485电平芯片所以要正确接收和发送数据,必需保证控制信号和数据的同步,否则要么发送数据丢失,要么接收数据可能丢失。

RS-485发送数据时的正确时序如图4所示。


              图4 RS-485的正确发送数据时序

在图4中,发送控制信号的宽度基本与数据信号的宽度一致,所以能保证发送数据的正确和发送后及时转为接收。

图5 和图6 分别是控制信号太短和控制信号太长的情况。


                图5 RS-485控制信号太短时的时序


                图6 RS-485控制信号太短时的时序

在图5中,由于控制信号关闭过早,则第二个字节的后两位将发送错误;在图6中,由于控制信号关闭过迟,使485芯片在发送数据后,不能及时转到接收状态,此时总线若有数据过来,则本单元将不能正确接收。

总结:只要掌握上述波形分析方法,任何异步串行数据的接收和发送问题,基本都可以得到解决。

二、串口通信

2.1 串口的操作一般都通过四个步骤来完成:

1、打开串口
2、配置串口:对串口的波特率、数据位、停止位、校验码、等进行设置
3、读写串口
4、关闭串口

2.2 完整代码:

#include <fcntl.h>     //文件控制定义
#include <stdio.h>     //标准输入输出定义
#include <stdlib.h>     //标准函数库定义
#include <unistd.h>    //Unix标准函数定义 
#include <errno.h>     //错误好定义
#include <termios.h>   //POSIX终端控制定义
#include <sys/ioctl.h>   //ioctl函数定义
#include <string.h>     //字符操作
#include <sys/types.h>  
#include <sys/stat.h> 
#include <pthread.h>
#include <sys/timeb.h>

//时间戳
long long getSystemTime() {
    struct timeb t;
    ftime(&t);
    return 1000 * t.time + t.millitm;
}

 long long start;
 long long end;


//定义互斥量
pthread_mutex_t mutex;
int fd_gpio;

struct termios newtio, oldtio;
typedef struct {
        int  pin_idx;
        int  pin_dir;
        int  pin_sta;
} davinci_gio_arg;

typedef enum {
        AT91PIO_DIR_OUT = 0,
        AT91PIO_DIR_INP 
} davinci_gio_dir;
//驱动判断输入输出模式

davinci_gio_arg arg;

#define DEV_PIO_LED "/dev/pio"
// 需要手动添加设备号 mknod /dev/pio c 203 0
#define PIO_NUM 47
// 47pin 为控制输入输出方向引脚
#define DEV_UART	"/dev/ttyS1"
// /dev/ttyS1 为串口设备

#define IOCTL_PIO_SETDIR	1		//set gpio direct
#define IOCTL_PIO_GETDIR	2		//get gpio direct
#define IOCTL_PIO_SETSTA	3		//set gpio status
#define IOCTL_PIO_GETSTA	4		//get gpio status

//保存信息
int log_init( const char *strFileName )
{
	int fdLog = -1;

	if( -1 == (fdLog = open( strFileName,  O_CREAT|O_TRUNC ) ) )
	{
	}
	close( fdLog );
}

int log_out( const char *strFileName, const char * szLog )
{
	int fdLog = -1;

	if( -1 == (	fdLog = open( strFileName,  O_CREAT|O_WRONLY|O_APPEND ) ) )
	{
		printf( "LOG (%s) open error!\n", strFileName );
		return -1;
	}

	write( fdLog, szLog, strlen( szLog ) );

	close( fdLog );

	return 0;
}

//配置串口
/* 参数说明:fd 设备文件描述符,nspeed 波特率,nbits 数据位数(7位或8位),
            parity 奇偶校验位('n'或'N'为无校验位,'o'或'O'为偶校验,'e'或'E'奇校验),
		    nstop 停止位(1位或2位)
  成功返回1,失败返回-1。 
*/
int set_com_opt( int fd, int nspeed, int nbits, char parity, int nstop )
{
	char szTmp[128];
//打印配置信息
	sprintf( szTmp, "set_com_opt - speed:%d,bits:%d,parity:%c,stop:%d\n", 
				nspeed, nbits, parity, nstop );
    
	log_out( "./485.log", szTmp );
	//保存并测试现在有串口参数设置,在这里如果串口号等出错,会有相关的出错信息 
	if( tcgetattr( fd, &oldtio ) != 0 )
	{
	
	sprintf( szTmp, "SetupSerial 1" );

	log_out( "./485.log", szTmp );

		perror( "SetupSerial 1" );
		return -1;
	}

    //修改输出模式,原始数据输出
	bzero( &newtio, sizeof( newtio ));
	newtio.c_cflag &=~(OPOST);

	//屏蔽其他标志位
	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;
	default:
		perror("Unsupported date bit!\n");
		return -1;
	}
	
	//设置校验位
	switch( parity )
	{
	case 'n':
	case 'N':  //无奇偶校验位
		newtio.c_cflag &= ~PARENB;
		newtio.c_iflag &= ~INPCK;
		break;
	case 'o':
	case 'O':	 //设置为奇校验
		newtio.c_cflag |= ( PARODD | PARENB );
		newtio.c_iflag |= ( INPCK | ISTRIP );
		break;
	case 'e':
	case 'E':  //设置为偶校验
		newtio.c_iflag |= ( INPCK |ISTRIP );
		newtio.c_cflag |= PARENB;
		newtio.c_cflag &= ~PARODD;
		break;
	default:
		perror("unsupported parity\n");
		return -1;
	}

	//设置停止位
	switch( nstop )	
	{
	case 1:	
		newtio.c_cflag &= ~CSTOPB;
		break;
	case 2:
		newtio.c_cflag |= CSTOPB;
		break;
	default :
		perror("Unsupported stop bit\n");
		return -1;
	}

	//设置波特率
	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;
	}

	//设置等待时间和最小接收字符
	newtio.c_cc[VTIME] = 0;  
	newtio.c_cc[VMIN] = 0;   
//VTIME=0,VMIN=0,不管能否读取到数据,read都会立即返回。

//输入模式
	newtio.c_lflag &= ~(ICANON|ECHO|ECHOE|ISIG);
//设置数据流控制
	newtio.c_iflag &= ~(IXON|IXOFF|IXANY); //使用软件流控制
//如果发生数据溢出,接收数据,但是不再读取 刷新收到的数据但是不读
	tcflush( fd, TCIFLUSH ); 
//激活配置 (将修改后的termios数据设置到串口中)
	if( tcsetattr( fd, TCSANOW, &newtio ) != 0 )
	{
	sprintf( szTmp, "serial set error!\n" );

	log_out( "./485.log", szTmp );
		perror( "serial set error!" );
		return -1;
	}

	log_out( "./485.log", "serial set ok!\n" );
	return 1;
}

//打开串口并返回串口设备文件描述
int open_com_dev( char *dev_name )
{
	int fd;
		char szTmp[128];

	log_init( "./485.log" );
	if(( fd = open( dev_name, O_RDWR|O_NOCTTY|O_NDELAY)) == -1 )
	{

		perror("open\n");
		//printf("Can't open Serial %s Port!\n", dev_name );
		sprintf( szTmp, "Can't open Serial %s Port!\n", dev_name );
		
		log_out( "./485.log", szTmp );

		return -1;
	}

	sprintf( szTmp, "open %s ok!\n", dev_name );
	log_out( "./485.log", szTmp );

	if(fcntl(fd,F_SETFL,0)<0)
	{
		printf("fcntl failed!\n");
	}
	//printf("Open %s ok\n",dev_name );
	return fd;
}

//发送云台数据
void* task(void* p)
{
	char ch;
	int j = 0, nread = 0;
	while(scanf ("%s", &ch) ==1)
	{
		pthread_mutex_lock (&mutex);
		arg.pin_sta = 1;     //设为高电平 发送态
		ioctl(fd_gpio, IOCTL_PIO_SETSTA, &arg);
		
		int fd = open_com_dev( DEV_UART );
		if( fd < 0 )
		{
			printf( "open UART device error! %s\n", DEV_UART );
		}
		else
		set_com_opt(fd, 2400,8,'n',1);
		//set_com_opt(fd, 9600,8,'n',1);

		char buff[] = {0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11};
    	int len = write(fd,buff,sizeof (buff));
   		if (len < 0)
   		{
			perror ("write err");
			exit (-1);
   		}
		//打印发送数据
		printf ("sead: ");
		for (j = 0; j < sizeof(buff); j++)
		{
			printf ("%02X ", buff[j]);
		}
		printf ("\n"); 
	
		//清除scanf缓冲区
		scanf ("%*[^\n]");
		scanf ("%*c");
		close (fd);
		pthread_mutex_unlock (&mutex);
	}
}

//单片机数据收发
void* task1(void* p)
{
	char buf[255];
	int j = 0, res = 0, nread = 0, i = 0;
	while (1) {
	pthread_mutex_lock (&mutex);

	arg.pin_sta = 1;     //设为高电平 发送态
	ioctl(fd_gpio, IOCTL_PIO_SETDIR, &arg);
	//打开/dev/pio 
	int fd_s = open_com_dev( DEV_UART );
	if( fd_s < 0 )
	{
		printf( "open UART device error! %s\n", DEV_UART );
	}
	else
		set_com_opt(fd_s, 2400,8,'n',1);
		//set_com_opt(fd_s, 9600,8,'n',1);
  
	//发送数据
	char buff[] = {0xaa,0x55,0x05,0x00,0x33,0x44,0x14,0x90,0x00};
	int len = write(fd_s,buff,sizeof (buff));
	if (len < 0)
	{
		perror ("write err");
		exit (-1);
	}
	printf ("sead: ");
	for (j = 0; j < sizeof (buff); j++)
	{
		printf ("%02X ", buff[j]);
	}
	printf ("\n");
  
	close (fd_s);
	start=getSystemTime();
	arg.pin_sta = 0;   //设为低电平 接收态  
	ioctl(fd_gpio, IOCTL_PIO_SETSTA, &arg);
	int fd_r=open_com_dev( DEV_UART );
	if( fd_r < 0 )
	{
		printf( "open UART device error! %s\n", DEV_UART );
	}
	else
		set_com_opt(fd_r, 2400,8,'n',1);
		//set_com_opt(fd_r, 9600,8,'n',1);

	//执行select
	fd_set rd;  
	FD_ZERO(&rd);  
	FD_SET(fd_r, &rd);  
	if ((res = select (fd_r+1,&rd, NULL, NULL, NULL) )< 0)
	{
		perror ("read err");
		exit (-1);
	}

	memset (buf, 0, sizeof (buf));
	if (FD_ISSET (fd_r, &rd))
	{
		//接收数据 8 8 2 
		int res1 = 0;
		while ((nread = read(fd_r, buf, 8)) > 0)
		{
			//打印接收数据
			for (i = 0; i < nread; i++)
			{
				printf ("%02X ", buf[i]);
			}
			//退出循环, 这里有点疑问
			res1 += nread;
			if (res1 == 18)
			{
				memset (buf, 0, sizeof (buf));
				printf ("\n");
				break;
			}
		}
	}
	close (fd_r); 
	pthread_mutex_unlock (&mutex);
	end=getSystemTime();
	printf("time: %lld ms\n", end-start);
	usleep (200000);
	}
}

int main (void)
{

	int error = 0, error1 = 0;
	arg.pin_idx = PIO_NUM;        
	arg.pin_dir = AT91PIO_DIR_OUT;
	//打开/dev/pio设备
	fd_gpio = open(DEV_PIO_LED, O_RDWR); 
	if(fd_gpio < 0)
	{
		perror("fd_gpio open err");
		exit (-1);
	}

	//初始化互斥量
	pthread_mutex_init (&mutex, 0);
	pthread_t tid, tid1;
	//创建线程
	error = pthread_create (&tid, NULL, task, NULL);
	error1 = pthread_create (&tid1, NULL, task1, NULL);
	//等待线程结束
	pthread_join (tid, NULL);
	pthread_join (tid1, NULL);
	//销毁互斥量
	pthread_mutex_destroy(&mutex);
	//关闭设备	
	close (fd_gpio);
	return 0;
}
执行结果:

三、串口通信总结

虽然以上代码只有三百多行,但是其包含的内容确是很多的,下面就一一的来总结。

一般招聘信息上 都会有这样一项要求。了解Modbus基于RS485,RS232,以太网等总线的通讯协议,熟练操作Modbus相关软件。

上面我们对RS485,RS232硬件做了分析,接下来我们看一下软件上面该如何处理。
主要分为下面部分来讲:

(1)串口编程详解

参看:Linux串口编程详解 

前面已经提到过Linux下皆为文件,这当然也包括我们今天的主角 UART0 串口。因此对他的一切操作都和文件的操作一样(涉及到了open,read,write,close等文件的基本操作)。

(一)Linux下的串口编程又那几部分组成

 

 

1.    打开串口

2.    串口初始化

3.    读串口或写串口

4.    关闭串口

(二)串口的打开

既然串口在linux中被看作了文件,那么在对文件进行操作前先要对其进行打开操作。

1.在Linxu中,串口设备是通过串口终端设备文件来访问的

即通过访问/dev/ttyS0,/dev/ttyS1,/dev/ttyS2这些设备文件实现对串口的访问。

==============================

这里有个问题:

你怎么知道访问的是哪个串口?

可以进行一下测试,echo hello > /dev/ttyS0  

看看是否有hello输出。

如果串口使用不对,会出现错误:

setup serial:bad file descriptor
set parity Error

==============================

2.调用open()函数来代开串口设备,对于串口的打开操作,必须使用O_NOCTTY参数。

l  O_NOCTTY:表示打开的是一个终端设备,程序不会成为该端口的控制终端。如果不使用此标志,任务一个输入(eg:键盘中止信号等)都将影响进程。

l  O_NDELAY:表示不关心DCD信号线所处的状态(端口的另一端是否激活或者停止)。不说明这个标志的话,该程序就会在DCD信号线为低电平时停止。

3.打开串口模块有那及部分组成

1> 调用open()函数打开串口,获取串口设备文件描述符

2> 获取串口状态,判断是否阻塞

3> 测试打开的文件描述符是否为终端设备

 

4程序:

/*****************************************************************
* 名称:                    UART0_Open
* 功能:                    打开串口并返回串口设备文件描述
* 入口参数:            fd    :文件描述符     port :串口号(ttyS0,ttyS1,ttyS2)
* 出口参数:            正确返回为1,错误返回为0
*****************************************************************/
int UART0_Open(int fd,char* port)
{
 
      fd = open( port, O_RDWR|O_NOCTTY|O_NDELAY);
      if (FALSE == fd)
             {
                    perror("Can't Open Serial Port");
                    return(FASLE);
             }
  //判断串口的状态是否为阻塞状态                            
  if(fcntl(fd, F_SETFL, 0) < 0)
      {
             printf("fcntl failed!/n");
           return(FALSE);
      }     
  else
  {
       printf("fcntl=%d/n",fcntl(fd, F_SETFL,0));
  }
  //测试是否为终端设备    
  if(0 == isatty(STDIN_FILENO))
      {
             printf("standard input is not a terminal device/n");
        return(FALSE);
      }
  else
      {
           printf("isatty success!/n");
      }       
  printf("fd->open=%d/n",fd);
  return fd;
}

(三)串口的初始化

1.    在linux中的串口初始化和前面的串口初始化一样。

需要设置串口波特率,数据流控制,帧的格式(即数据位个数,停止位,校验位,数据流控制)

2.    串口初始化模块有那几部分组成:

1> 设置波特率

2> 设置数据流控制

3> 设置帧的格式(即数据位个数,停止位,校验位)


说明:

1> 设置串口参数时要用到termios结构体,因此先要通过函数 tcgettattr(fd,&options)获得串口指向termios结构的指针。termios.h头文件中定义的termios结构,如下:

struct termios
{
   tcflag_t  c_iflag;   //输入模式标志
   tcflag_t  c_oflag;  //输出模式标志
   tcflag_t  c_cflag;  //控制模式标志
   tcflag_t  c_lflag;   //本地模式标志
   cc_t   c_line;              //line discipline
   cc_t   c_cc[NCC];    //control characters
}

2> 通过cfsetispeed函数和cfsetospeed函数用来设置串口的输入/输出波特率。一般情况下,输入和输出波特率相等的。

3> 设置数据位可以通过修改termios机构体中c_flag来实现。其中CS5,CS6,CS7,CS8对应数据位的5,6,7,8。在设置数据位时,必须要用CSIZE做位屏蔽。

以下是几个数据位、停止位和校验位的设置方法:(以下均为1位停止位)

8位数据位、无校验位:
Opt.c_cflag &= ~PARENB;
Opt.c_cflag &= ~CSTOPB;
Opt.c_cflag &= ~CSIZE;
Opt.c_cflag |= CS8;
7位数据位、奇校验:
Opt.c_cflag |= PARENB;
Opt.c_cflag |= PARODD;
Opt.c_cflag &= ~CSTOPB;
Opt.c_cflag &= ~CSIZE;
Opt.c_cflag |= CS7;
7位数据位、偶校验:
Opt.c_cflag |= PARENB;
Opt.c_cflag &= ~PARODD;
Opt.c_cflag &= ~CSTOPB;
Opt.c_cflag &= ~CSIZE;
Opt.c_cflag |= CS7;
7位数据位、Space校验:
Opt.c_cflag &= ~PARENB;
Opt.c_cflag &= ~CSTOPB;
Opt.c_cflag &= ~CSIZE;
Opt.c_cflag |= CS7;

4> 数据流控制是使用何种方法来标志数据传输的开始和结束。

5> 在设置完波特率,数据流控制,数据位,校验位,停止位,停止位后,还要设置最小等待时间和最小接收字符。

6> 在完成配置后要通过tcsetattr()函数来激活配置。

3.程序:

/*******************************************************************
* 名称:                UART0_Set
* 功能:                设置串口数据位,停止位和效验位
* 入口参数:        fd         串口文件描述符
*                              speed      串口速度
*                              flow_ctrl  数据流控制
*                           databits   数据位   取值为 7 或者8
*                           stopbits   停止位   取值为 1 或者2
*                           parity     效验类型 取值为N,E,O,,S
*出口参数:              正确返回为1,错误返回为0
*******************************************************************/
int UART0_Set(int fd,int speed,int flow_ctrl,int databits,int stopbits,int parity)
{
   
      int   i;
         int   status;
         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 };
         
    struct termios options;
   
    /*tcgetattr(fd,&options)得到与fd指向对象的相关参数,并将它们保存于options,该函数,还可以测试配置是否正确,该串口是否可用等。若调用成功,函数返回值为0,若调用失败,函数返回值为1.
    */
    if  ( tcgetattr( fd,&options)  !=  0)
       {
          perror("SetupSerial 1");    
          return(FALSE); 
       }
  
    //设置串口输入波特率和输出波特率
    for ( i= 0;  i < sizeof(speed_arr) / sizeof(int);  i++)
                {
              if  (speed == name_arr[i])
              {       
                          cfsetispeed(&Options, speed_arr[i]); 
                          cfsetospeed(&Options, speed_arr[i]);  
              }
       }     
   
    //修改控制模式,保证程序不会占用串口
    options.c_cflag |= CLOCAL;
    //修改控制模式,使得能够从串口中读取输入数据
    options.c_cflag |= CREAD;
  
    //设置数据流控制
    switch(flow_ctrl)
    {
      
       case 0 ://不使用流控制
              options.c_cflag &= ~CRTSCTS;
              break;   
      
       case 1 ://使用硬件流控制
              options.c_cflag |= CRTSCTS;
              break;
       case 2 ://使用软件流控制
              options.c_cflag |= IXON | IXOFF | IXANY;
              break;
    }
    //设置数据位
    options.c_cflag &= ~CSIZE; //屏蔽其他标志位
    switch (databits)
    {  
       case 5    :
                     options.c_cflag |= CS5;
                     break;
       case 6    :
                     options.c_cflag |= CS6;
                     break;
       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; 
                 options.c_iflag &= ~INPCK;    
                 break; 
       case 'o':  
       case 'O'://设置为奇校验    
                 options.c_cflag |= (PARODD | PARENB); 
                 options.c_iflag |= INPCK;             
                 break; 
       case 'e': 
       case 'E'://设置为偶校验  
                 options.c_cflag |= PARENB;       
                 options.c_cflag &= ~PARODD;       
                 options.c_iflag |= INPCK;       
                 break;
       case 's':
       case 'S': //设置为空格 
                 options.c_cflag &= ~PARENB;
                 options.c_cflag &= ~CSTOPB;
                 break; 
        default:  
                 fprintf(stderr,"Unsupported parity/n");   
                 return (FALSE); 
    } 
    // 设置停止位 
    switch (stopbits)
    {  
       case 1:   
                 options.c_cflag &= ~CSTOPB; 
                 break; 
       case 2:   
                 options.c_cflag |= CSTOPB; 
                         break;
       default:   
                       fprintf(stderr,"Unsupported stop bits/n"); 
                       return (FALSE);
    }
   
    //修改输出模式,原始数据输出
    options.c_oflag &= ~OPOST;
   
    //设置等待时间和最小接收字符
    options.c_cc[VTIME] = 1; /* 读取一个字符等待1*(1/10)s */  
    options.c_cc[VMIN] = 1; /* 读取字符的最少个数为1 */
   
    //如果发生数据溢出,接收数据,但是不再读取
    tcflush(fd,TCIFLUSH);
   
    //激活配置 (将修改后的termios数据设置到串口中)
    if (tcsetattr(fd,TCSANOW,&options) != 0)  
    {
               perror("com set error!/n");  
       return (FALSE); 
    }
    return (TRUE); 
}
/*******************************************************************
* 名称:                  UART0_Init()
* 功能:                串口初始化
* 入口参数:        fd           文件描述符   
*               speed     串口速度
*                              flow_ctrl   数据流控制
*               databits    数据位   取值为 7 或者8
*                           stopbits   停止位   取值为 1 或者2
*                           parity     效验类型 取值为N,E,O,,S                    
* 出口参数:        正确返回为1,错误返回为0
*******************************************************************/
int UART0_Init(int fd, int speed,int flow_ctrlint databits,int stopbits,int parity)
{
    int err;
    //设置串口数据帧格式
    if (UART0_Set(fd,115200,0,8,1,'N') == FALSE)
    {                                                     
        return FALSE;
    }
    else
    {
               return  TRUE;
        }
}
注意:
如果不是开发终端之类的,只是串口传输数据,而不需要串口来处理,那么使用原始模式 (Raw Mode) 方式来通讯,设置方式如下:
options.c_lflag  &= ~(ICANON | ECHO | ECHOE | ISIG);  /*Input*/
options.c_oflag  &= ~OPOST;   /*Output*/


c_cc 数组的 VSTART 和 VSTOP 元素被设定成 DC1 和 DC3,代表 ASCII 标准的 XON 和 XOFF 字符,如果在传输这两个字符的时候就传不过去,需要把软件流控制屏蔽,即:
Opt.c_iflag &= ~ (IXON | IXOFF | IXANY);
有时候,在用write发送数据时没有键入回车,信息就发送不出去,这主要是因为我们在输入输出时是按照规范模式接收到回车或换行才发送,而更多情况下我们是不必键入回车或换行的。此时应转换到行方式输入,不经处理直接发送,设置如下:
Opt.c_lflag &= ~ (ICANON | ECHO | ECHOE | ISIG);
还存在这样的情况:发送字符0X0d的时候,往往接收端得到的字符是 0X0a,原因是因为在串口设置中 c_iflag 和c_oflag 中存在从 NL-CR 和 CR-NL 的映射,即串口能把回车和换行当成同一个字符,可以进行如下设置屏蔽之:
Opt.c_iflag &= ~ (INLCR | ICRNL | IGNCR);
Opt.c_oflag &= ~(ONLCR | OCRNL);


注意 tcsetattr 函数中使用的标志:
TCSANOW:立即执行而不等待数据发送或者接受完成。
TCSADRAIN:等待所有数据传递完成后执行。
TCSAFLUSH:刷新输入和输出缓冲区,使之变化。

(四)串口的读写函数

读写串口是通过使用read函数和write函数来实现的。程序:

/*******************************************************************
* 名称:                  UART0_Recv
* 功能:                接收串口数据
* 入口参数:        fd                  :文件描述符    
*                              rcv_buf     :接收串口中数据存入rcv_buf缓冲区中
*                              data_len    :一帧数据的长度
* 出口参数:        正确返回为1,错误返回为0
*******************************************************************/
int UART0_Recv(int fd, char *rcv_buf,int data_len)
{
    int len,fs_sel;
    fd_set fs_read;
   
    struct timeval time;
   
    FD_ZERO(&fs_read);
    FD_SET(fd,&fs_read);
   
    time.tv_sec = 10;
    time.tv_usec = 0;
   
    //使用select实现串口的多路通信
    fs_sel = select(fd+1,&fs_read,NULL,NULL,&time);
    if(fs_sel)
       {
              len = read(fd,data,data_len);
              return len;
       }
    else
       {
              return FALSE;
       }     
}
/*******************************************************************
* 名称:                UART0_Send
* 功能:                发送数据
* 入口参数:        fd                  :文件描述符    
*                              send_buf    :存放串口发送数据
*                              data_len    :一帧数据的个数
* 出口参数:        正确返回为1,错误返回为0
*******************************************************************/
int UART0_Send(int fd, char *send_buf,int data_len)
{
    int len = 0;
   
    len = write(fd,send_buf,data_len);
    if (len == data_len )
       {
              return len;
       }     
    else   
        {
               
                tcflush(fd,TCOFLUSH);
                return FALSE;
        }
    }

(五)关闭串口

在完成对串口设备的操作后,要调用close函数关闭该文件描述符。程序:
/******************************************************
* 名称:                UART0_Close
* 功能:                关闭串口并返回串口设备文件描述
* 入口参数:        fd    :文件描述符   
* 出口参数:        void
*******************************************************************/
 
void UART0_Close(int fd)
{
    close(fd);
}

(六)附录

c_cflag用于设置控制参数,除了波特率外还包含以下内容: 
EXTA         External rate clock
EXTB         External rate clock
CSIZE         Bit mask for data bits
CS5         5个数据位
CS6         6个数据位
CS7         7个数据位
CS8         8个数据位
CSTOPB         2个停止位(清除该标志表示1个停止位
PARENB         允许校验位
PARODD         使用奇校验(清除该标志表示使用偶校验)
CREAD         Enable receiver
HUPCL         Hangup (drop DTR) on last close
CLOCAL         Local line – do not change “owner” of port
LOBLK         Block job control outpu
c_cflag标志可以定义CLOCAL和CREAD,这将确保该程序不被其他端口控制和信号干扰,同时串口驱动将读取进入的数据。CLOCAL和CREAD通常总是被是能的。

c_lflag用于设置本地模式,决定串口驱动如何处理输入字符,设置内容如下:
ISIG            Enable SIGINTR, SIGSUSP, SIGDSUSP, and SIGQUIT signals 
ICANON         Enable canonical input (else raw) 
XCASE         Map uppercase \lowercase (obsolete) 
ECHO         Enable echoing of input characters 
ECHOE         Echo erase character as BS-SP-BS 
ECHOK         Echo NL after kill character 
ECHONL         Echo NL 
NOFLSH         Disable flushing of input buffers after interrupt or quit characters 
IEXTEN         Enable extended functions 
ECHOCTL         Echo control characters as ^char and delete as ~? 
ECHOPRT         Echo erased character as character erased 
ECHOKE         BS-SP-BS entire line on line kill 
FLUSHO         Output being flushed 
PENDIN         Retype pending input at next read or input char 
TOSTOP         Send SIGTTOU for background output

c_iflag用于设置如何处理串口上接收到的数据,包含如下内容:
INPCK         Enable parity check 
IGNPAR         Ignore parity errors 
PARMRK      Mark parity errors 
ISTRIP         Strip parity bits 
IXON         Enable software flow control (outgoing) 
IXOFF         Enable software flow control (incoming) 
IXANY         Allow any character to start flow again 
IGNBRK         Ignore break condition 
BRKINT         Send a SIGINT when a break condition is detected 
INLCR         Map NL to CR 
IGNCR         Ignore CR 
ICRNL         Map CR to NL 
IUCLC         Map uppercase to lowercase 
IMAXBEL      Echo BEL on input line too long

c_oflag用于设置如何处理输出数据,包含如下内容:
OPOST         Postprocess output (not set = raw output) 
OLCUC         Map lowercase to uppercase 
ONLCR         Map NL to CR-NL 
OCRNL         Map CR to NL 
NOCR         No CR output at column 0 
ONLRET      NL performs CR function 
OFILL         Use fill characters for delay 
OFDEL         Fill character is DEL 
NLDLY         Mask for delay time needed between lines 
NL0            No delay for NLs 
NL1            Delay further output after newline for 100 milliseconds 
CRDLY      Mask for delay time needed to return carriage to left column 
CR0            No delay for CRs 
CR1            Delay after CRs depending on current column position 
CR2            Delay 100 milliseconds after sending CRs 
CR3            Delay 150 milliseconds after sending CRs 
TABDLY      Mask for delay time needed after TABs 
TAB0            No delay for TABs 
TAB1         Delay after TABs depending on current column position 
TAB2         Delay 100 milliseconds after sending TABs 
TAB3         Expand TAB characters to spaces 
BSDLY      Mask for delay time needed after BSs 
BS0         No delay for BSs 
BS1         Delay 50 milliseconds after sending BSs 
VTDLY      Mask for delay time needed after VTs 
VT0         No delay for VTs 
VT1         Delay 2 seconds after sending VTs 
FFDLY      Mask for delay time needed after FFs 
FF0         No delay for FFs 
FF1         Delay 2 seconds after sending FFs

c_cc定义了控制字符,包含以下内容:
VINTR  Interrupt  CTRL-C 
VQUIT  Quit    CTRL-Z 
VERASE   Erase    Backspace (BS) 
VKILL   Kill-line   CTRL-U 
VEOF   End-of-file   CTRL-D 
VEOL   End-of-line   Carriage return (CR) 
VEOL2   Second    end-of-line Line feed (LF) 
VMIN   Minimum number of characters to read  
VSTART   Start flow   CTRL-Q (XON) 
VSTOP   Stop flow   CTRL-S (XOFF) 
VTIME   Time to wait for data (tenths of seconds) 
注意:

控制符VTIME和VMIN之间有复杂的关系。VTIME定义要求等待的时间(百毫米,通常是unsigned char变量),而VMIN定义了要求等待的最小字节数(相比之下,read函数的第三个参数指定了要求读的最大字节数)。
如果VTIME=0,VMIN=要求等待读取的最小字节数,read必须在读取了VMIN个字节的数据或者收到一个信号才会返回。
如果VTIME=时间量,VMIN=0,不管能否读取到数据,read也要等待VTIME的时间量。
如果VTIME=时间量,VMIN=要求等待读取的最小字节数,那么将从read读取第一个字节的数据时开始计时,并会在读取到VMIN个字节或者VTIME时间后返回。
如果VTIME=0,VMIN=0,不管能否读取到数据,read都会立即返回。

(七)参看代码

/************************Copyright(c)******************************* 
**                       西安邮电学院 
**                       graduate school 
**                                     XNMS项目组 
**                       WebSite :blog.csdn.net/tigerjb 
**------------------------------------------FileInfo------------------------------------------------------- 
** File name:                 main.c 
** Last modified Date:  2011-01-31 
** Last Version:              1.0 
** Descriptions:             
**------------------------------------------------------------------------------------------------------ 
** Created by:               冀博 
** Created date:            2011-01-31 
** Version:                            1.0 
** Descriptions:             The original version 
**------------------------------------------------------------------------------------------------------ 
** Modified by: 
** Modified date: 
** Version: 
** Descriptions: 
*******************************************************************/  
   
   
//串口相关的头文件  
#include<stdio.h>      /*标准输入输出定义*/  
#include<stdlib.h>     /*标准函数库定义*/  
#include<unistd.h>     /*Unix 标准函数定义*/  
#include<sys/types.h>   
#include<sys/stat.h>     
#include<fcntl.h>      /*文件控制定义*/  
#include<termios.h>    /*PPSIX 终端控制定义*/  
#include<errno.h>      /*错误号定义*/  
#include<string.h>  
   
   
//宏定义  
#define FALSE  -1  
#define TRUE   0  
   
/******************************************************************* 
* 名称:                  UART0_Open 
* 功能:                打开串口并返回串口设备文件描述 
* 入口参数:        fd    :文件描述符     port :串口号(ttyS0,ttyS1,ttyS2) 
* 出口参数:        正确返回为1,错误返回为0 
*******************************************************************/  
int UART0_Open(int fd,char* port)  
{  
     
         fd = open( port, O_RDWR|O_NOCTTY|O_NDELAY);  
         if (FALSE == fd)  
                {  
                       perror("Can't Open Serial Port");  
                       return(FALSE);  
                }  
     //恢复串口为阻塞状态                                 
     if(fcntl(fd, F_SETFL, 0) < 0)  
                {  
                       printf("fcntl failed!\n");  
                     return(FALSE);  
                }       
         else  
                {  
                  printf("fcntl=%d\n",fcntl(fd, F_SETFL,0));  
                }  
      //测试是否为终端设备      
      if(0 == isatty(STDIN_FILENO))  
                {  
                       printf("standard input is not a terminal device\n");  
                  return(FALSE);  
                }  
  else  
                {  
                     printf("isatty success!\n");  
                }                
  printf("fd->open=%d\n",fd);  
  return fd;  
}  
/******************************************************************* 
* 名称:                UART0_Close 
* 功能:                关闭串口并返回串口设备文件描述 
* 入口参数:        fd    :文件描述符     port :串口号(ttyS0,ttyS1,ttyS2) 
* 出口参数:        void 
*******************************************************************/  
   
void UART0_Close(int fd)  
{  
    close(fd);  
}  
   
/******************************************************************* 
* 名称:                UART0_Set 
* 功能:                设置串口数据位,停止位和效验位 
* 入口参数:        fd        串口文件描述符 
*                              speed     串口速度 
*                              flow_ctrl   数据流控制 
*                           databits   数据位   取值为 7 或者8 
*                           stopbits   停止位   取值为 1 或者2 
*                           parity     效验类型 取值为N,E,O,,S 
*出口参数:          正确返回为1,错误返回为0 
*******************************************************************/  
int UART0_Set(int fd,int speed,int flow_ctrl,int databits,int stopbits,int parity)  
{  
     
      int   i;  
         int   status;  
         int   speed_arr[] = { B115200, B19200, B9600, B4800, B2400, B1200, B300};  
     int   name_arr[] = {115200,  19200,  9600,  4800,  2400,  1200,  300};  
           
    struct termios options;  
     
    /*tcgetattr(fd,&options)得到与fd指向对象的相关参数,并将它们保存于options,该函数还可以测试配置是否正确,该串口是否可用等。若调用成功,函数返回值为0,若调用失败,函数返回值为1. 
    */  
    if  ( tcgetattr( fd,&options)  !=  0)  
       {  
          perror("SetupSerial 1");      
          return(FALSE);   
       }  
    
    //设置串口输入波特率和输出波特率  
    for ( i= 0;  i < sizeof(speed_arr) / sizeof(int);  i++)  
                {  
                     if  (speed == name_arr[i])  
                            {               
                                 cfsetispeed(&options, speed_arr[i]);   
                                 cfsetospeed(&options, speed_arr[i]);    
                            }  
              }       
     
    //修改控制模式,保证程序不会占用串口  
    options.c_cflag |= CLOCAL;  
    //修改控制模式,使得能够从串口中读取输入数据  
    options.c_cflag |= CREAD;  
    
    //设置数据流控制  
    switch(flow_ctrl)  
    {  
        
       case 0 ://不使用流控制  
              options.c_cflag &= ~CRTSCTS;  
              break;     
        
       case 1 ://使用硬件流控制  
              options.c_cflag |= CRTSCTS;  
              break;  
       case 2 ://使用软件流控制  
              options.c_cflag |= IXON | IXOFF | IXANY;  
              break;  
    }  
    //设置数据位  
    //屏蔽其他标志位  
    options.c_cflag &= ~CSIZE;  
    switch (databits)  
    {    
       case 5    :  
                     options.c_cflag |= CS5;  
                     break;  
       case 6    :  
                     options.c_cflag |= CS6;  
                     break;  
       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;   
                 options.c_iflag &= ~INPCK;      
                 break;   
       case 'o':    
       case 'O'://设置为奇校验      
                 options.c_cflag |= (PARODD | PARENB);   
                 options.c_iflag |= INPCK;               
                 break;   
       case 'e':   
       case 'E'://设置为偶校验    
                 options.c_cflag |= PARENB;         
                 options.c_cflag &= ~PARODD;         
                 options.c_iflag |= INPCK;        
                 break;  
       case 's':  
       case 'S': //设置为空格   
                 options.c_cflag &= ~PARENB;  
                 options.c_cflag &= ~CSTOPB;  
                 break;   
        default:    
                 fprintf(stderr,"Unsupported parity\n");      
                 return (FALSE);   
    }   
    // 设置停止位   
    switch (stopbits)  
    {    
       case 1:     
                 options.c_cflag &= ~CSTOPB; break;   
       case 2:     
                 options.c_cflag |= CSTOPB; break;  
       default:     
                       fprintf(stderr,"Unsupported stop bits\n");   
                       return (FALSE);  
    }  
     
  //修改输出模式,原始数据输出  
  options.c_oflag &= ~OPOST;  
    
  options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);//我加的  
//options.c_lflag &= ~(ISIG | ICANON);  
     
    //设置等待时间和最小接收字符  
    options.c_cc[VTIME] = 1; /* 读取一个字符等待1*(1/10)s */    
    options.c_cc[VMIN] = 1; /* 读取字符的最少个数为1 */  
     
    //如果发生数据溢出,接收数据,但是不再读取 刷新收到的数据但是不读  
    tcflush(fd,TCIFLUSH);  
     
    //激活配置 (将修改后的termios数据设置到串口中)  
    if (tcsetattr(fd,TCSANOW,&options) != 0)    
           {  
               perror("com set error!\n");    
              return (FALSE);   
           }  
    return (TRUE);   
}  
/******************************************************************* 
* 名称:                UART0_Init() 
* 功能:                串口初始化 
* 入口参数:        fd       :  文件描述符    
*               speed  :  串口速度 
*                              flow_ctrl  数据流控制 
*               databits   数据位   取值为 7 或者8 
*                           stopbits   停止位   取值为 1 或者2 
*                           parity     效验类型 取值为N,E,O,,S 
*                       
* 出口参数:        正确返回为1,错误返回为0 
*******************************************************************/  
int UART0_Init(int fd, int speed,int flow_ctrl,int databits,int stopbits,int parity)  
{  
    int err;  
    //设置串口数据帧格式  
    if (UART0_Set(fd,19200,0,8,1,'N') == FALSE)  
       {                                                           
        return FALSE;  
       }  
    else  
       {  
               return  TRUE;  
        }  
}  
   
/******************************************************************* 
* 名称:                  UART0_Recv 
* 功能:                接收串口数据 
* 入口参数:        fd                  :文件描述符     
*                              rcv_buf     :接收串口中数据存入rcv_buf缓冲区中 
*                              data_len    :一帧数据的长度 
* 出口参数:        正确返回为1,错误返回为0 
*******************************************************************/  
int UART0_Recv(int fd, char *rcv_buf,int data_len)  
{  
    int len,fs_sel;  
    fd_set fs_read;  
     
    struct timeval time;  
     
    FD_ZERO(&fs_read);  
    FD_SET(fd,&fs_read);  
     
    time.tv_sec = 10;  
    time.tv_usec = 0;  
     
    //使用select实现串口的多路通信  
    fs_sel = select(fd+1,&fs_read,NULL,NULL,&time);  
    if(fs_sel)  
       {  
              len = read(fd,rcv_buf,data_len);  
          printf("I am right!(version1.2) len = %d fs_sel = %d\n",len,fs_sel);  
              return len;  
       }  
    else  
       {  
          printf("Sorry,I am wrong!");  
              return FALSE;  
       }       
}  
/******************************************************************** 
* 名称:                  UART0_Send 
* 功能:                发送数据 
* 入口参数:        fd                  :文件描述符     
*                              send_buf    :存放串口发送数据 
*                              data_len    :一帧数据的个数 
* 出口参数:        正确返回为1,错误返回为0 
*******************************************************************/  
int UART0_Send(int fd, char *send_buf,int data_len)  
{  
    int len = 0;  
     
    len = write(fd,send_buf,data_len);  
    if (len == data_len )  
              {  
                     return len;  
              }       
    else     
        {  
                 
                tcflush(fd,TCOFLUSH);  
                return FALSE;  
        }  
     
}  
   
   
int main(int argc, char **argv)  
{  
    int fd;                            //文件描述符  
    int err;                           //返回调用函数的状态  
    int len;                          
    int i;  
    char rcv_buf[100];         
    char send_buf[20]="tiger john";  
    if(argc != 3)  
       {  
              printf("Usage: %s /dev/ttySn 0(send data)/1 (receive data) \n",argv[0]);  
              return FALSE;  
       }  
    fd = UART0_Open(fd,argv[1]); //打开串口,返回文件描述符  
    do{  
                  err = UART0_Init(fd,19200,0,8,1,'N');  
                  printf("Set Port Exactly!\n");  
       }while(FALSE == err || FALSE == fd);  
     
    if(0 == strcmp(argv[2],"0"))  
           {  
                  for(i = 0;i < 10;i++)  
                         {  
                                len = UART0_Send(fd,send_buf,10);  
                                if(len > 0)  
                                       printf(" %d send data successful\n",i);  
                                else  
                                       printf("send data failed!\n");  
                            
                                sleep(2);  
                         }  
                  UART0_Close(fd);               
           }  
    else  
           {  
                                        
           while (1) //循环读取数据  
                  {    
                     len = UART0_Recv(fd, rcv_buf,9);  
                     if(len > 0)  
                            {  
                       rcv_buf[len] = '\0';  
                                   printf("receive data is %s\n",rcv_buf);  
                       printf("len = %d\n",len);  
                            }  
                     else  
                            {  
                                   printf("cannot receive data\n");  
                            }  
                     sleep(2);  
              }              
       UART0_Close(fd);   
           }  
}  
    
/*********************************************************************                            End Of File                          ** 
*******************************************************************/  

(2)select 函数用法

参看:UNIX再学习 -- 函数 select、poll、epoll 

(3)多线程编程-互斥锁

(4)Linux获取毫秒级时间

参看:C语言再学习 -- 时间函数

©️2020 CSDN 皮肤主题: 猿与汪的秘密 设计师:上身试试 返回首页
实付 19.90元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值