linux串口读写

① linux怎么读取串口数据

#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>

#defineFALSE-1
#defineTRUE0

intspeed_arr[]={B38400,B19200,B9600,B4800,B2400,B1200,B300,B38400,B19200,B9600,B4800,B2400,B1200,B300,};
intname_arr[]={38400,19200,9600,4800,2400,1200,300,38400,19200,9600,4800,2400,1200,300,};
voidset_speed(intfd,intspeed){
inti;
intstatus;
structtermiosOpt;
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("tcsetattrfd1");
return;
}
tcflush(fd,TCIOFLUSH);
}
}
}

intset_Parity(intfd,intdatabits,intstopbits,intparity)
{
	structtermiosoptions;
	if(tcgetattr(fd,&options)!=0){
		perror("SetupSerial1");
		return(FALSE);
	}
	options.c_cflag&=~CSIZE;
	switch(databits)
	{
	case7:		
		options.c_cflag|=CS7;
		break;
	case8:
		options.c_cflag|=CS8;
		break;
	default:
		fprintf(stderr,"Unsupporteddatasize
");return(FALSE);
	}
	switch(parity)
	{
		case'n':
		case'N':
			options.c_cflag&=~PARENB;/*Clearparityenable*/
			options.c_iflag&=~INPCK;/*Enableparitychecking*/
			break;
		case'o':
		case'O':
			options.c_cflag|=(PARODD|PARENB);
			options.c_iflag|=INPCK;/*Disnableparitychecking*/
			break;
		case'e':
		case'E':
			options.c_cflag|=PARENB;/*Enableparity*/
			options.c_cflag&=~PARODD;
			options.c_iflag|=INPCK;/*Disnableparitychecking*/
			break;
		case'S':
		case's':/*asnoparity*/
		options.c_cflag&=~PARENB;
			options.c_cflag&=~CSTOPB;break;
		default:
			fprintf(stderr,"Unsupportedparity
");
			return(FALSE);
		}
	
	switch(stopbits)
	{
		case1:
			options.c_cflag&=~CSTOPB;
			break;
		case2:
			options.c_cflag|=CSTOPB;
		break;
		default:
			fprintf(stderr,"Unsupportedstopbits
");
			return(FALSE);
	}
	/*Setinputparityoption*/
	if(parity!='n')
		options.c_iflag|=INPCK;
	tcflush(fd,TCIFLUSH);
	options.c_cc[VTIME]=150;
	options.c_cc[VMIN]=0;/*UpdatetheoptionsanddoitNOW*/
	if(tcsetattr(fd,TCSANOW,&options)!=0)
	{
		perror("SetupSerial3");
		return(FALSE);
	}
	return(TRUE);
}

intmain()
{
	printf("Thisprogramupdateslasttimeat%s%s
",__TIME__,__DATE__);
	printf("STDIOCOM1
");
	intfd;
	fd=open("/dev/ttyS0",O_RDWR);
	if(fd==-1)
	{
		perror("serialporterror
");
	}
	else
	{
		printf("open");
		printf("%s",ttyname(fd));
		printf("succesfully
");
	}

	set_speed(fd,115200);
	if(set_Parity(fd,8,1,'N')==FALSE){
		printf("SetParityError
");
		exit(0);
	}
	charbuf[]="fe55aa07bc010203040506073d";
	write(fd,&buf,26);
	charbuff[512];	
	intnread;	
	while(1)
	{
		if((nread=read(fd,buff,512))>0)
		{
			printf("
Len:%d
",nread);
			buff[nread+1]='';
			printf("%s",buff);
		}
	}
	close(fd);
	return0;
}

② linux下串口读写问题挂死

这样写肯定会写死的啊..写(也就是串口发送数据)实际应用不会这么频繁的.楼主可以在写后加上一个sleep(1);这样就不会写死了..
高并发读写这样设计也是错误的应该用队列来处理..

③ linux内核自带的s3c2440串口驱动里怎么配置串口啊，该怎么读写串口呢

是的，串口设备也是字符设备呀
但是一般serial
0会被当作console，也就是你在pc上通过超级终端等进去的那个

④ linux串口读取问题

首先你确定你那串口是否有东西可读？ 就是你上面说的“一个文件不停的写数据到串口”！你可以先不这样读取，你可以在终端上用cat试试是否有数据可读：cat /dev/ttyS0

如果有的话，那你就检查串口设置是否正确，如波特率，数据位，停止位，校验位等！

最后就是你读取的函数了，看看先不要用printf打印字符串了，先看看十六进制是否有，然后再看字符等！

就是以上一些，你还可以参考Linux下串口文档，网络上很多的……

⑤ 在linux系统下怎么读取串口服务器的实时数据

Linux串口读写：
#include <stdio.h> /*标准输入输出定义*/
#include <stdlib.h> /*标准函数库定义*/
#include <unistd.h> /*Unix 标准函数定义*/
#include <sys/types.h>
#include <sys/stat.h>
#include "string.h"
#include <fcntl.h> /*文件控制定义*/
#include <termios.h> /*PPSIX 终端控制定义*/
#include <errno.h> /*错误号定义*/

#define FALSE -1
#define TRUE 0

/*********************************************************************/
int OpenDev(char *Dev)
{
int fd = open( Dev, O_RDWR | O_NOCTTY ); //| O_NOCTTY | O_NDELAY
if (-1 == fd)
{
perror("Can't Open Serial Port");
return -1;
}
else
return fd;
}

/**
*@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(fd, TCSANOW, &Opt);
if (status != 0) {
perror("tcsetattr fd1");
return;
}
tcflush(fd,TCIOFLUSH);
}
}
}

/**
*@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;
options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); /*Input*/
options.c_oflag &= ~OPOST; /*Output*/
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 */
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/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);
}
/* Set input parity option */
if (parity != 'n')
options.c_iflag |= INPCK;
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);
}

int main(int argc, char **argv)
{

int fd;
int nread;
char buff[512];
char *dev = "/dev/ttyS0"; //串口二
fd = OpenDev(dev);
set_speed(fd,4800);
if (set_Parity(fd,8,1,'N') == FALSE)
{
printf("Set Parity Error/n");
exit (0);
}
int i;
i = getchar();
if ( i == '1')
{
while (1) //循环读取数据
{
while((nread = read(fd, buff, 512))>0)
{
printf("/nLen %d/n",nread);
buff[nread+1] = '/0';
printf( "/n%s", buff);
}
}
}
if ( i == '2')
{
while (1) //循环写入数据
{

gets(buff);

printf("------buff--->%s<--------/n",buff);
int num = strlen(buff);
printf("--------num---->%d<--------------/n",num);
if ( num > 0)
{
printf("Wirte num not NULL./r/n");
nread = write(fd, buff ,num);
if(nread == -1)
{
printf("Wirte sbuf error./n");
}
printf("--nread---->%d<-----------/n",nread);
}

}
}
close(fd);
//exit (0);
}

⑥ 如何在linux内核模块中对串口进行读写 100flycofei

多用户系统，除了系统资源有争抢以外，2个用户的操作不会互相影响操作界面，有字符界面，也有图形界面。linux的图形界面和系统关系不大，只是一个应用程序，图形界面有很多种，每个人都可以定制自己的linux文件系统，和图形界面一样，跟linux.

⑦ linux中如何读取串口收发数据

用echo可以，不过需要一个串口的软件，就跟win的超级终端一样，开启后连接串口，然后另一边发送数据，你这边就能显示出来，我记得好像叫做minicom

⑧ 如何在Linux下用java读写串口设备

java 是否有权限访问该串口

⑨ 如何在linux内核模块中对串口进行读写

是的,串口设备也是字符设备呀 但是一般serial 0会被当作console,也就是你在pc上通过超级终端等进去的那个