Linux系统串口接收数据编程

最新推荐文章于 2024-06-15 18:51:07 发布
最新推荐文章于 2024-06-15 18:51:07 发布
阅读量2.8w 收藏 101
点赞数 9
分类专栏： Linux C学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bg2bkk/article/details/8668576
版权

         之前基于IBM deveplopworks社区的代码，做了串口初始化和发送的程序，今天在此基础上添加了读取串口数据的程序。首先是最简单的循环读取程序，第二个是通过软中断方式，使用信号signal机制读取串口，这里需要注意的是硬件中断是设备驱动层级的，而读写串口是用户级行为，只能通过信号机制模拟中断，信号机制的发生和处理其实于硬件中断无异，第三个是通过select系统调用，在没有数据时阻塞进程，串口有数据需要读时唤醒进程。第二个和第三个例子都能用来后台读取数据，值得学习。

代码一：循环读取数据

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

#define FALSE -1
#define TRUE 0

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

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 */
			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; 
	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()
{
	printf("This program updates last time at %s   %s\n",__TIME__,__DATE__);
	printf("STDIO COM1\n");
	int fd;
	fd = open("/dev/ttyS0",O_RDWR);
	if(fd == -1)
	{
		perror("serialport error\n");
	}
	else
	{
		printf("open ");
		printf("%s",ttyname(fd));
		printf(" succesfully\n");
	}

	set_speed(fd,115200);
	if (set_Parity(fd,8,1,'N') == FALSE)  {
		printf("Set Parity Error\n");
		exit (0);
	}
	char buf[] = "fe55aa07bc010203040506073d";
	write(fd,&buf,26);
	char buff[512];	
	int nread;	
	while(1)
	{
		if((nread = read(fd, buff, 512))>0)
		{
			printf("\nLen: %d\n",nread);
			buff[nread+1] = '\0';
			printf("%s",buff);
		}
	}
	close(fd);
	return 0;
}

代码清单二：通过signal机制读取数据 

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

#define FALSE -1
#define TRUE 0
#define flag 1
#define noflag 0

int wait_flag = noflag;
int STOP = 0;
int res;

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

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 */
      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;
  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);
}

void
signal_handler_IO (int status)
{
  printf ("received SIGIO signale.\n");
  wait_flag = noflag;
}

int
main ()
{
  printf ("This program updates last time at %s   %s\n", __TIME__, __DATE__);
  printf ("STDIO COM1\n");
  int fd;
  struct sigaction saio;
  fd = open ("/dev/ttyUSB0", O_RDWR);
  if (fd == -1)
    {
      perror ("serialport error\n");
    }
  else
    {
      printf ("open ");
      printf ("%s", ttyname (fd));
      printf (" succesfully\n");
    }

  saio.sa_handler = signal_handler_IO;
  sigemptyset (&saio.sa_mask);
  saio.sa_flags = 0;
  saio.sa_restorer = NULL;
  sigaction (SIGIO, &saio, NULL);

  //allow the process to receive SIGIO
  fcntl (fd, F_SETOWN, getpid ());
  //make the file descriptor asynchronous
  fcntl (fd, F_SETFL, FASYNC);

  set_speed (fd, 115200);
  if (set_Parity (fd, 8, 1, 'N') == FALSE)
    {
      printf ("Set Parity Error\n");
      exit (0);
    }

  char buf[255];
while (STOP == 0)
    {
      usleep (100000);
      /* after receving SIGIO ,wait_flag = FALSE,input is availabe and can be read */
      if (wait_flag == 0)
	{
	  memset (buf, 0, sizeof(buf));
	  res = read (fd, buf, 255);
	  printf ("nread=%d,%s\n", res, buf);
//	  if (res ==1)
//	    STOP = 1;		/*stop loop if only a CR was input */
	  wait_flag = flag;	/*wait for new input */
	}
    }


  close (fd);
  return 0;
}


代码三：通过select系统调用进行io多路切换，实现异步读取串口数据

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

#define FALSE -1
#define TRUE 0
#define flag 1
#define noflag 0

int wait_flag = noflag;
int STOP = 0;
int res;

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

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 */
      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;
  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);
}

void
signal_handler_IO (int status)
{
  printf ("received SIGIO signale.\n");
  wait_flag = noflag;
}

int
main ()
{
  printf ("This program updates last time at %s   %s\n", __TIME__, __DATE__);
  printf ("STDIO COM1\n");
  int fd;
  fd = open ("/dev/ttyUSB0", O_RDWR);
  if (fd == -1)
    {
      perror ("serialport error\n");
    }
  else
    {
      printf ("open ");
      printf ("%s", ttyname (fd));
      printf (" succesfully\n");
    }

  set_speed (fd, 115200);
  if (set_Parity (fd, 8, 1, 'N') == FALSE)
    {
      printf ("Set Parity Error\n");
      exit (0);
    }

  char buf[255];
  fd_set rd;
  int nread = 0;
  while(1)
  {
  	FD_ZERO(&rd);
	FD_SET(fd, &rd);
	while(FD_ISSET(fd, &rd))
	{
		if(select(fd+1, &rd, NULL,NULL,NULL) < 0)
		{
			perror("select error\n");
		}
		else
		{
			while((nread = read(fd, buf, sizeof(buf))) > 0)
			{
				printf("nread = %d,%s\n",nread, buf);
				printf("test\n");
				memset(buf, 0 , sizeof(buf));
			}
		}
	}
  }
  close (fd);
  return 0;
}



bg2bkk
关注
  • 9
    点赞
  • 踩
  • 101
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
基于Linux平台的串口数据接收程序
01-17
基于Linux平台的串口数据接收源程序，可以直接在Linxu平台下进行功能测试。
linux 串口程序源码,Linux串口通信编程
weixin_34746495的博客
05-01 597
/*串口设备无论是在工控领域，还是在嵌入式设备领域，应用都非常广泛。而串口编程也就显得必不可少。偶然的一次机会，需要使用串口，而且操作系统还要求是Linux，因此，趁着这次机会，综合别人的代码，进行了一次整理和封装。具体的封装格式为C代码，这样做是为了很好的移植性，使它可以在C和C++环境下，都可以编译和使用。代码的头文件如下： */////////////////////////////////...
Linux下的串口通信
最新发布
zxz_Fine的博客
06-15 1234
串口通信
linux 串口编程详解
来一杯奶茶
09-27 1986
首页 移动开发 架构 云计算/大数据 互联网 运维 数据库 前端 编程语言 研发管理 综合 全部 Linux串口编程详解 linux串口相关设置函数 转载 2014年10月30日 17:59:41 1615 1 1 tcgetattr    函数用于获取与终端相关的参数。
信号（signal）介绍
nicholasmaxwell的专栏
06-29 3209
信号是Linux编程中非常重要的部分，本文将详细介绍信号机制的基本概念、Linux对信号机制的大致实现方法、如何使用信号，以及有关信号的几个系统调用。 信号机制是进程之间相互传递消息的一种方法，信号全称为软中断信号，也有人称作软中断。从它的命名可以看出，它的实质和使用很象中断。所以，信号可以说是进程控制的一部分。 一、信号的基本概念 本节先介绍信号的一些基本概念，然后给出一些基本的信号类型和信号对
Linux 环境下接收串口数据——详细代码
努力努力努力
08-15 3177
Linux 环境下接收串口数据详细代码
Linux c++多线程串口编程demo
01-26
在Linux系统中，C++是一种常用的编程语言，用于开发高效且复杂的软件，特别是在涉及系统级编程和硬件交互时。本示例"Linux c++多线程串口编程demo"聚焦于利用多线程技术实现串口通信，这是一种常见的硬件接口，用于...
linux串口数据转TCP
10-27
标题“Linux串口数据转TCP”指的是一种技术，它允许通过Linux系统的串行接口（如UART）收发的数据转换为TCP/IP协议进行传输。这通常涉及到一个中间软件层，称为“串口到TCP网关”，它可以将串口数据流实时转发到TCP...
Linux串口编程详解
03-25
Linux串口编程详解 串口编程是计算机科学中的一种重要技术，它允许计算机与外部设备进行通信。编程语言中串口编程的实现方式有多种，包括使用C语言、Java语言等。 Linux串口编程详解中，串口是计算机上的串行通讯...
Linux环境下串口编程.rar_linux 串口_linux 串口 编程_串口编程
09-24
Linux串口编程广泛应用于嵌入式系统、自动化设备、遥测系统、GPS模块、无线模块等，通过串口进行数据交换和控制指令的发送。 总之，Linux串口编程是开发者必备的技能之一，通过理解和实践，可以掌握如何在Linux...
Unix/Linux编程：终端编程
OceanStar的博客
06-10 1602
概述 传统型终端和终端模拟器都需要同终端驱动程序相关联，由驱动程序负责处理设备上的输入和输出（如果是终端模拟器，这里的设备就是一个伪终端） 当执行输入时，驱动程序可以工作在如下两种模式下 规范模式(默认)：在这种模式下，终端的输入是按行来处理的，而且可以进行行编辑操作。每一行都由换行符来结束，当用户按下回车键可以产生换行符。在终端上执行的read()调用只会在一行输入完成只会才会返回，而且最多只会返回一行（如果read()请求的字节数少于当前行的可用字节，那么剩下的字节在下次read()调用时可用）。 非
linux串口读写程序
shenlong1356的博客
05-21 2123
#include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <termios.h> #include <unistd.h> #include <stdio.h> #include <string.h> #include <stdio.h> #include <stdlib.h> #include <stri..
Linux系统编程：串口编程
AngerTiger的博客
04-23 2093
Linux系统编程：串口编程Linux下的串口概述Linux串口编程代码解析编译和测试代码中的常量介绍 Linux下的串口概述 常见的数据通信的基本方式分为并行通信和串行通信。 1.并行通信：利用多条数据传输线将一个资料的各位同事传送。特点是速度快，通信距离近。 2.串行通信：利用一条传输线将数据一位一位地顺序传输。特点是通信线路简单，利用简单线缆就可以实现通信，降低成本，适合远距离通信但传输速度...
linux 串口select函数,Linux下用select查询串口数据
weixin_36423916的博客
05-04 1230
2楼Linux下用select查询串口数据Linux下直接用read读串口可能会造成堵塞，或数据读出错误。然而用select先查询com口，再用read去读就可以避免，并且当 com口延时时，程序可以退出，这样就不至于由于com口堵塞，程序就死了。我的代码如下：boolReadDevice(inthComm,unsignedlonguLen,char*pData){intnre...
linux串口编程 select
自由的天空
08-12 1824
1、串口的阻塞和非阻塞 阻塞的定义： 对于read，block指当串口输入缓冲区没有数据的时候，read函数将会阻塞在这里，一直到串口输入缓冲区中有数据可读取，read读到了需要的字节数之后，返回值为读到的字节数，然后整个程序才继续运行下去；（收） 对于write，block指当串口输出缓冲区满，或剩下的空间小于将要写入的字节数，则write将阻塞，一直到串口输出缓冲区中剩下的空间大于等于将要写入的字节数，执行写入操作，返回写入的字节数，然后整个程序才继续运行下去。（发...
linux 串口读写c代码
yyt4913的专栏
01-08 2404
#include <stdio.h> #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <termios.h> #include <string.h> #include <errno.h> #include <stdlib.h> #include <sys/.
linux c 串口接收不定长数据
09-06
在Linux C编程中，接收不定长数据的串口通信可以通过以下的步骤实现： 1. 打开串口：使用open系统调用打开串口设备文件，例如"/dev/ttyS0"。确保正确设置串口的baud rate、数据位、校验位和停止位等参数。 2. 配置串口：通过ioctl系统调用设置串口的属性，例如禁用规范模式，并设置输入输出波特率、数据位、校验位和停止位等参数。 3. 接收数据：使用read系统调用从串口读取数据。由于数据不定长，可以考虑一次读取一个字节，并将其存储在一个缓冲区中。 4. 处理数据：根据接收的数据进行处理。可以通过循环读取，直到接收到特定的结束标志或达到预定的数据长度。也可以通过超时机制或读取的字节数判断数据接收完成。 5. 关闭串口：使用close系统调用关闭串口设备文件。 需要注意的是，在接收不定长数据时，可能会遇到以下一些问题： 1. 数据的结束标志：如果数据中没有特定的结束标志，在处理数据时可能需要使用自定义的结束标志或者通过计数器判断数据的长度。 2. 超时处理：如果数据的接收时间较长，可以通过设置串口的超时时间，当一定时间内没有数据到达时，进行超时处理。 3. 数据缓冲区大小：由于数据的长度不确定，需要考虑缓冲区的大小，确保足够存储接收的数据。 总之，在Linux C中接收不定长数据的串口通信，需要打开和配置串口，循环读取数据并进行处理，最后关闭串口。通过合适的结束标志、超时处理和缓冲区管理等技术，可以实现稳定、可靠地接收不定长数据。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值