Linux下读写UART串口的代码

最新推荐文章于 2024-05-11 13:51:31 发布
最新推荐文章于 2024-05-11 13:51:31 发布
阅读量8.8k 收藏 15
点赞数 1
分类专栏： Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010388659/article/details/81206370
版权

Linux下读写UART串口的代码

 

转载至：http://blog.csdn.net/yao_guet/article/details/24768967

2014-04-30 09:35 15672人阅读 评论(2) 收藏 举报

 分类：

Linux（35）  Android（37） 

版权声明：本文为博主原创文章，未经博主允许不得转载。

Linux下读写UART串口的代码，从IBM Developer network上拿来的东西，操作比较的复杂，就直接跳过了，好在代码能用，记录一下～

两个有用的函数～

 

[cpp] view plain copy

  1.   
  2. /** 
  3. *@brief  设置串口通信速率 
  4. *@param  fd     类型 int  打开串口的文件句柄 
  5. *@param  speed  类型 int  串口速度 
  6. *@return  void 
  7. */  
  8. int speed_arr[] = {B115200, B38400, B19200, B9600, B4800, B2400, B1200, B300,  
  9.                    B115200, B38400, B19200, B9600, B4800, B2400, B1200, B300, };  
  10. int name_arr[] = {115200, 38400, 19200, 9600, 4800, 2400, 1200,  300,   
  11.                   115200, 38400, 19200, 9600, 4800, 2400, 1200,  300, };  
  12. void set_speed(int fd, int speed){  
  13.   int   i;   
  14.   int   status;   
  15.   struct termios   Opt;  
  16.   tcgetattr(fd, &Opt);   
  17.   for ( i= 0;  i < sizeof(speed_arr) / sizeof(int);  i++) {   
  18.     if  (speed == name_arr[i]) {       
  19.       tcflush(fd, TCIOFLUSH);       
  20.       cfsetispeed(&Opt, speed_arr[i]);    
  21.       cfsetospeed(&Opt, speed_arr[i]);     
  22.       status = tcsetattr(fd, TCSANOW, &Opt);    
  23.       if  (status != 0) {          
  24.         perror("tcsetattr fd1");    
  25.         return;       
  26.       }      
  27.       tcflush(fd,TCIOFLUSH);     
  28.     }    
  29.   }  
  30. }  


[cpp] view plain copy

  1.   
  2. /** 
  3. *@brief   设置串口数据位，停止位和效验位 
  4. *@param  fd     类型  int  打开的串口文件句柄 
  5. *@param  databits 类型  int 数据位   取值 为 7 或者8 
  6. *@param  stopbits 类型  int 停止位   取值为 1 或者2 
  7. *@param  parity  类型  int  效验类型 取值为N,E,O,,S 
  8. */  
  9. int set_Parity(int fd,int databits,int stopbits,int parity)  
  10. {   
  11.     struct termios options;   
  12.     if  ( tcgetattr( fd,&options)  !=  0) {   
  13.         perror("SetupSerial 1");       
  14.         return(FALSE);    
  15.     }  
  16.     options.c_cflag &= ~CSIZE;   
  17.     switch (databits) /*设置数据位数*/  
  18.     {     
  19.     case 7:       
  20.         options.c_cflag |= CS7;   
  21.         break;  
  22.     case 8:       
  23.         options.c_cflag |= CS8;  
  24.         break;     
  25.     default:      
  26.         fprintf(stderr,"Unsupported data size\n"); return (FALSE);    
  27.     }  
  28.     switch (parity)   
  29.     {     
  30.         case 'n':  
  31.         case 'N':      
  32.             options.c_cflag &= ~PARENB;   /* Clear parity enable */  
  33.             options.c_iflag &= ~INPCK;     /* Enable parity checking */   
  34.             break;    
  35.         case 'o':     
  36.         case 'O':       
  37.             options.c_cflag |= (PARODD | PARENB); /* 设置为奇效验*/    
  38.             options.c_iflag |= INPCK;             /* Disnable parity checking */   
  39.             break;    
  40.         case 'e':    
  41.         case 'E':     
  42.             options.c_cflag |= PARENB;     /* Enable parity */      
  43.             options.c_cflag &= ~PARODD;   /* 转换为偶效验*/       
  44.             options.c_iflag |= INPCK;       /* Disnable parity checking */  
  45.             break;  
  46.         case 'S':   
  47.         case 's':  /*as no parity*/     
  48.             options.c_cflag &= ~PARENB;  
  49.             options.c_cflag &= ~CSTOPB;break;    
  50.         default:     
  51.             fprintf(stderr,"Unsupported parity\n");      
  52.             return (FALSE);    
  53.         }    
  54.     /* 设置停止位*/    
  55.     switch (stopbits)  
  56.     {     
  57.         case 1:      
  58.             options.c_cflag &= ~CSTOPB;    
  59.             break;    
  60.         case 2:      
  61.             options.c_cflag |= CSTOPB;    
  62.            break;  
  63.         default:      
  64.              fprintf(stderr,"Unsupported stop bits\n");    
  65.              return (FALSE);   
  66.     }   
  67.     /* Set input parity option */   
  68.     if (parity != 'n')     
  69.         options.c_iflag |= INPCK;   
  70.     tcflush(fd,TCIFLUSH);  
  71.     options.c_cc[VTIME] = 150; /* 设置超时15 seconds*/     
  72.     options.c_cc[VMIN] = 0; /* Update the options and do it NOW */  
  73.     if (tcsetattr(fd,TCSANOW,&options) != 0)     
  74.     {   
  75.         perror("SetupSerial 3");     
  76.         return (FALSE);    
  77.     }   
  78.     options.c_lflag  &= ~(ICANON | ECHO | ECHOE | ISIG);  /*Input*/  
  79.     options.c_oflag  &= ~OPOST;   /*Output*/  
  80.     return (TRUE);    
  81. }  


调用的方法比较的简单，如下，fd是打开的tty设备的文件句柄

 

 

[cpp] view plain copy

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


总的测试代码如下。

 

 

[cpp] view plain copy

  1. #include <sys/types.h>  
  2.   
  3. #include <sys/stat.h>  
  4. #include <fcntl.h>  
  5. #include <termios.h>  
  6. #include <stdio.h>  
  7. #define BAUDRATE        B115200  
  8. #define UART_DEVICE     "/dev/ttyS3"  
  9.   
  10. #define FALSE  -1  
  11. #define TRUE   0  
  12.   
  13. /** 
  14. *@brief  设置串口通信速率 
  15. *@param  fd     类型 int  打开串口的文件句柄 
  16. *@param  speed  类型 int  串口速度 
  17. *@return  void 
  18. */  
  19. int speed_arr[] = {B115200, B38400, B19200, B9600, B4800, B2400, B1200, B300,  
  20.                    B115200, B38400, B19200, B9600, B4800, B2400, B1200, B300, };  
  21. int name_arr[] = {115200, 38400, 19200, 9600, 4800, 2400, 1200,  300,   
  22.                   115200, 38400, 19200, 9600, 4800, 2400, 1200,  300, };  
  23. void set_speed(int fd, int speed){  
  24.   int   i;   
  25.   int   status;   
  26.   struct termios   Opt;  
  27.   tcgetattr(fd, &Opt);   
  28.   for ( i= 0;  i < sizeof(speed_arr) / sizeof(int);  i++) {   
  29.     if  (speed == name_arr[i]) {       
  30.       tcflush(fd, TCIOFLUSH);       
  31.       cfsetispeed(&Opt, speed_arr[i]);    
  32.       cfsetospeed(&Opt, speed_arr[i]);     
  33.       status = tcsetattr(fd, TCSANOW, &Opt);    
  34.       if  (status != 0) {          
  35.         perror("tcsetattr fd1");    
  36.         return;       
  37.       }      
  38.       tcflush(fd,TCIOFLUSH);     
  39.     }    
  40.   }  
  41. }  
  42.   
  43. /** 
  44. *@brief   设置串口数据位，停止位和效验位 
  45. *@param  fd     类型  int  打开的串口文件句柄 
  46. *@param  databits 类型  int 数据位   取值 为 7 或者8 
  47. *@param  stopbits 类型  int 停止位   取值为 1 或者2 
  48. *@param  parity  类型  int  效验类型 取值为N,E,O,,S 
  49. */  
  50. int set_Parity(int fd,int databits,int stopbits,int parity)  
  51. {   
  52.     struct termios options;   
  53.     if  ( tcgetattr( fd,&options)  !=  0) {   
  54.         perror("SetupSerial 1");       
  55.         return(FALSE);    
  56.     }  
  57.     options.c_cflag &= ~CSIZE;   
  58.     switch (databits) /*设置数据位数*/  
  59.     {     
  60.     case 7:       
  61.         options.c_cflag |= CS7;   
  62.         break;  
  63.     case 8:       
  64.         options.c_cflag |= CS8;  
  65.         break;     
  66.     default:      
  67.         fprintf(stderr,"Unsupported data size\n"); return (FALSE);    
  68.     }  
  69.     switch (parity)   
  70.     {     
  71.         case 'n':  
  72.         case 'N':      
  73.             options.c_cflag &= ~PARENB;   /* Clear parity enable */  
  74.             options.c_iflag &= ~INPCK;     /* Enable parity checking */   
  75.             break;    
  76.         case 'o':     
  77.         case 'O':       
  78.             options.c_cflag |= (PARODD | PARENB); /* 设置为奇效验*/    
  79.             options.c_iflag |= INPCK;             /* Disnable parity checking */   
  80.             break;    
  81.         case 'e':    
  82.         case 'E':     
  83.             options.c_cflag |= PARENB;     /* Enable parity */      
  84.             options.c_cflag &= ~PARODD;   /* 转换为偶效验*/       
  85.             options.c_iflag |= INPCK;       /* Disnable parity checking */  
  86.             break;  
  87.         case 'S':   
  88.         case 's':  /*as no parity*/     
  89.             options.c_cflag &= ~PARENB;  
  90.             options.c_cflag &= ~CSTOPB;break;    
  91.         default:     
  92.             fprintf(stderr,"Unsupported parity\n");      
  93.             return (FALSE);    
  94.         }    
  95.     /* 设置停止位*/    
  96.     switch (stopbits)  
  97.     {     
  98.         case 1:      
  99.             options.c_cflag &= ~CSTOPB;    
  100.             break;    
  101.         case 2:      
  102.             options.c_cflag |= CSTOPB;    
  103.            break;  
  104.         default:      
  105.              fprintf(stderr,"Unsupported stop bits\n");    
  106.              return (FALSE);   
  107.     }   
  108.     /* Set input parity option */   
  109.     if (parity != 'n')     
  110.         options.c_iflag |= INPCK;   
  111.     tcflush(fd,TCIFLUSH);  
  112.     options.c_cc[VTIME] = 150; /* 设置超时15 seconds*/     
  113.     options.c_cc[VMIN] = 0; /* Update the options and do it NOW */  
  114.     if (tcsetattr(fd,TCSANOW,&options) != 0)     
  115.     {   
  116.         perror("SetupSerial 3");     
  117.         return (FALSE);    
  118.     }   
  119.     options.c_lflag  &= ~(ICANON | ECHO | ECHOE | ISIG);  /*Input*/  
  120.     options.c_oflag  &= ~OPOST;   /*Output*/  
  121.     return (TRUE);    
  122. }  
  123.   
  124. int main(int argc, char *argv[])  
  125. {  
  126.   
  127.     int    fd, c=0, res;  
  128.   
  129.     char  buf[256];  
  130.   
  131.     printf("Start...\n");  
  132.     fd = open(UART_DEVICE, O_RDWR);  
  133.   
  134.     if (fd < 0) {  
  135.         perror(UART_DEVICE);  
  136.         exit(1);  
  137.     }  
  138.   
  139.     printf("Open...\n");  
  140.     set_speed(fd,115200);  
  141.     if (set_Parity(fd,8,1,'N') == FALSE)  {  
  142.         printf("Set Parity Error\n");  
  143.         exit (0);  
  144.     }  
  145.   
  146.     printf("Reading...\n");  
  147.     while(1) {  
  148.         res = read(fd, buf, 255);  
  149.   
  150.         if(res==0)  
  151.             continue;  
  152.         buf[res]=0;  
  153.   
  154.         printf("%s", buf);  
  155.           
  156.         if (buf[0] == 0x0d)  
  157.             printf("\n");  
  158.           
  159.         if (buf[0] == '@') break;  
  160.     }  
  161.   
  162.     printf("Close...\n");  
  163.     close(fd);  
  164.   
  165.     return 0;  
  166. }  

 

 

Linux 串口读写(一)   

串口简介

串行口是计算机一种常用的接口，具有连接线少，通讯简单，得到广泛的使用。常用的串口是 RS-232-C 接口（又称 EIA RS-232-C）它是在 1970 年由美国电子工业协会（EIA）联合贝尔系统、 调制解调器厂家及计算机终端生产厂家共同制定的用于串行通讯的标准。它的全名是"数据终端设备（DTE）和数据通讯设备（DCE）之间串行二进制数据交换接口技术标准"该标准规定采用一个 25 个脚的 DB25 连接器，对连接器的每个引脚的信号内容加以规定，还对各种信号的电平加以规定。传输距离在码元畸变小于4% 的情况下，传输电缆长度应为 50 英尺。

Linux 操作系统从一开始就对串行口提供了很好的支持

计算机串口的引脚说明

 

序号

信号名称

符号

流向

功能

2

发送数据

TXD

DTE→DCE

DTE发送串行数据

3

接收数据

RXD

DTE←DCE

DTE 接收串行数据

4

请求发送

RTS

DTE→DCE

DTE 请求 DCE 将线路切换到发送方式

5

允许发送

CTS

DTE←DCE

DCE 告诉 DTE 线路已接通可以发送数据

6

数据设备准备好

DSR

DTE←DCE

DCE 准备好

7

信号地

　

　

　　　信号公共地

8

载波检测

DCD

DTE←DCE

表示 DCE 接收到远程载波

20

数据终端准备好

DTR

DTE→DCE

DTE 准备好

22

振铃指示

RI

DTE←DCE

表示 DCE 与线路接通，出现振铃

 

 

串口操作

串口操作需要的头文件

 

#include     <stdio.h>      /*标准输入输出定义*/

#include     <stdlib.h>     /*标准函数库定义*/

#include     <unistd.h>     /*Unix 标准函数定义*/

#include     <sys/types.h>  /*数据类型，比如一些XXX_t的那种*/

#include     <sys/stat.h>   /*定义了一些返回值的结构，没看明白*/

#include     <fcntl.h>      /*文件控制定义*/

#include     <termios.h>    /*PPSIX 终端控制定义*/

#include     <errno.h>      /*错误号定义*/

 

 

打开串口

在 Linux 下串口文件是位于 /dev 下的

串口一 为 /dev/ttyS0

串口二 为 /dev/ttyS1

打开串口是通过使用标准的文件打开函数操作：

 

int fd;

/*以读写方式打开串口*/

fd = open( "/dev/ttyS0", O_RDWR);

if (-1 == fd){

/* 不能打开串口一*/

perror(" 提示错误！");

}

 

 

设置串口

最基本的设置串口包括波特率设置，效验位和停止位设置。

串口的设置主要是设置 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 */

};

 

 

设置这个结构体很复杂，我这里就只说说常见的一些设置：

波特率设置

下面是修改波特率的代码：

 

struct  termios Opt;

tcgetattr(fd, &Opt); /*获得当前设备模式，与终端相关的参数。fd=0标准输入*/

cfsetispeed(&Opt,B19200); /*设置结构termios输入波特率为19200Bps*/

cfsetospeed(&Opt,B19200);   /*fd应该是文件描述的意思*/

tcsetattr(fd,TCANOW,&Opt);/*设置终端参数，TCANOW修改立即发生*/

 

 

设置波特率的例子函数：

 

/**

*@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函数刷清(抛弃)输入缓存(终端驱动程序已接收到，但用户程序尚未读)或输出缓存(用户程序已经写，但尚未发送)。queue参数应是下列三个常数之一：

* TCIFLUSH刷清输入队列。

 * TCOFLUSH刷清输出队列。

* TCIOFLUSH刷清输入、输出队列。

 */

   tcflush(fd, TCIOFLUSH);//设置前flush    

   cfsetispeed(&Opt, speed_arr[i]); 

   cfsetospeed(&Opt, speed_arr[i]);  

   //通过tcsetattr函数把新的属性设置到串口上。

   //tcsetattr(串口描述符，立即使用或者其他标示，指向termios的指针)

   status = tcsetattr(fd, TCSANOW, &Opt); 

   if  (status != 0)

{       

      perror("tcsetattr fd1"); 

       return;    

    }   

    tcflush(fd,TCIOFLUSH);  //设置后flush

  } 

}

}

 

 

效验位和停止位的设置：

 

无效验

8位

Option.c_cflag &= ~PARENB; 
Option.c_cflag &= ~CSTOPB; 
Option.c_cflag &= ~CSIZE; 
Option.c_cflag |= ~CS8;

奇效验(Odd)

7位

Option.c_cflag |= ~PARENB; 
Option.c_cflag &= ~PARODD; 
Option.c_cflag &= ~CSTOPB; 
Option.c_cflag &= ~CSIZE; 
Option.c_cflag |= ~CS7;

偶效验(Even)

7位

Option.c_cflag &= ~PARENB; 
Option.c_cflag |= ~PARODD; 
Option.c_cflag &= ~CSTOPB; 
Option.c_cflag &= ~CSIZE; 
Option.c_cflag |= ~CS7;

Space效验

7位

Option.c_cflag &= ~PARENB; 
Option.c_cflag &= ~CSTOPB; 
Option.c_cflag &= &~CSIZE; 
Option.c_cflag |= CS8;

 

设置效验的函数：

 

/**

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

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

}

 

 

需要注意的是:

如果不是开发终端之类的，只是串口传输数据，而不需要串口来处理，那么使用原始模式(Raw Mode)方式来通讯，设置方式如下：

 

options.c_lflag  &= ~(ICANON | ECHO | ECHOE | ISIG);  /*Input*/

options.c_oflag  &= ~OPOST;   /*Output*/

 

 

读写串口

设置好串口之后，读写串口就很容易了，把串口当作文件读写就是。

  • 发送数据

 

char  buffer[1024];

int    Length;

int    nByte;

nByte = write(fd, buffer ,Length)

 

 

  • 读取串口数据

使用文件操作read函数读取，如果设置为原始模式(Raw Mode)传输数据，那么read函数返回的字符数是实际串口收到的字符数。

可以使用操作文件的函数来实现异步读取，如fcntl，或者select等来操作。

 

char  buff[1024];

int    Len;

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

 

 

关闭串口

关闭串口就是关闭文件。

 

close(fd);

 

  

可爱的豆子
关注
  • 1
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux tty驱动学习 - UART驱动的read操作流程
sbctsp的博客
01-12 7760
在用户空间对tty设备进行读操作，经过系统调用进入到tty核心层执行的第一个函数是tty_read()。在tty_read()函数中，从文件描述符file的私有数据结构中获得tty_struct，然后再从tty_struct中获取线路规程描述符。取得线路规程描述符后，直接调用线路规程的read()函数。 static ssize_t tty_read(struct file *file, cha
基于select的Linux串口485读写，文件描述符 fd_set
02-05
基于linux ，使用select检测串口句柄事件，同时进行超时判断的串口485读写操作。为高效可控的linux串口操作例程。tcsetattr，tcflush，select，ioctl，gettimeofday。485收发方向切换。
linux下读写uart串口,Linux串口以异步模式读取
weixin_34239861的博客
05-06 1164
我在Linux系统中从串口读取数据时遇到了麻烦 . 我正在尝试使用UART将传感器连接到linux系统 . 我可以读写/开发/ ttyS1 . 但问题是我不想从UART轮询消息 . 相反，我想使用异步模式来获取数据 . 随着数据的到来，回调函数将进入某个例程并运行我的代码 . 问题不在于传感器向我发送不同的数据包，每个数据包包含各种字节的数据 . 他们每一秒都来！例如：Time ...
[Linux] 串口读写
最新发布
qq_65198598的博客
05-11 503
可以使用cat来读取串口中的数据，如cat /dev/ttyS3，注意 在这里使用cat的时候串口会回显输入的数据，例如我在这里串口输入 123 ,注意点发送新行。也可以读取数据并保存到txt文本文件中，如cat /dev/ttyS3 > test.txt，这里不演示。读取函数为 read(fd,&readbuf,sizeof(readbuf));设置串口的属性为115200，校验位等都是通过这个命令设置。可以直接操作串口1/3，在这里使用串口3。通过串口输入内容会通过串口返回。ls 查看当前文件夹文件。
Linux串口读取与解析
在路上@Amos
02-02 3968
串口协议包的接收及解析处理 对于串口接收问题前面之前有文章介绍过串口缓存机制的应用。当然这里不应用缓存机制也是完全可行的。这里我们讲解基于不带串口缓存机制的处理。对于串口接收我们最常用的方式就是在串口中断中接收数据。 利用串口接收数据包信息大致分为下面三种情况： 接收一帧数据，对帧数据进行处理（可以利用串口接收非空中断和串口空闲中断实现） 中断中边接收边处理存储，并将有效数据存储起来，再对有效数据进行解析。 将接收到的数据全部存入缓存，从缓存中提取数据并做处理。 ...
linux 串口uart的使用详解
u011311263的专栏
08-02 8560
1.对于在uart在linux上面的使用有几个地方需要注意的 a.输入数据格式的设置（使用read（）函数时） 设置方式：  /*Canonical Input*/  //termios_new.c_lflag |= (ICANON | ECHO | ECHOE);  /*Raw Input*/  //termios_new.c_lflag &amp;= ~(ICANON | ECHO | ...
Linux下串口信息的读取
qqwangfan的专栏
01-30 4715
在Linux下串口信息的读取有了一点心得体会。　　　1. 打开串口　　　与其他的关于设备编程的方法一样，在Linux下，操作、控制串口也是通过操作起设备文件进行的。在Linux下，串口的设备文件是/dev/ttyS0或/dev/ttyS1等。因此要读写串口，我们首先要打开串口：　　　char *dev = "/dev/ttyS0"； //串口1　　　int fd = open（ dev， O_RDWR ）；　　　//| O_NOCTTY | O_NDELAY　　　if （-1 == fd）　　　{　　　pe
uart串口打开和读写
12-03
uart串口应用开发，串口打开，串口的读写，我自己调试过是可以的，可以互相学习。int UartRead(int uartFd,char *buff,int bufLen) { int nRead = 0; if(uartFd 0){ buff[nRead]=0x0; } return nRead; }
uart_comm.zip_Linux uart读写_comm
09-24
通过封装串口操作类 实现串口的配置和串口的读写等功能 析构函数自动释放串口设备
Linux环境下使用线程方式操作UART读写功能
03-04
Linux环境下使用线程方式操作UART的方法，实现了串口打开，关闭，发送数据，接收数据功能，具体内容如下： 1. 串口发送数据 2. 串口通过终端方式接收数据 函数接口如下： 打开串口函数：usr_serial_open 关闭串口...
linux 下标准串口操作程序
11-13
标准的linux下串口操作，真正产品使用，支持读写初始化等，支持阻塞读取，支持timeout机制，支持各种模式配置
Linux-循环读取UART串口数据编程
lysine_的博客
09-09 783
Linux的UART串口通信编程。
java非阻塞 串口读数据_linux下串口的开发之非阻塞异步读
weixin_33676046的博客
02-16 200
读取串口数据使用文件操作read函数读取，如果设置为原始模式(Raw Mode)传输数据，那么read函数返回的字符数是实际串口收到的字符数。charbuff[1024];int Len;intreadByte = read(fd,buff,Len);可以使用操作文件的函数来实现异步读取，如fcntl，或者select等来操作。void SERIAL_RX(void){//read(...
linux uart 线程 c,在Linux下UART轮询期间处理CTRL-C内核
weixin_35681965的博客
05-10 182
ssize_t serp_read(struct file *filep, char __user *buf, size_t count, loff_t *offp){ssize_t cnt;char *buffer;int i;buffer = kmalloc(count * sizeof(char), GFP_KERNEL);for (i = 0; i != count; ++i) {buff...
Linux串口中的超时设置
wo_wuhao
11-03 5205
Linux串口中的超时设置
linux串口异步通讯,串口异步通信模式USART
weixin_31834087的博客
05-10 587
串口异步通信模式USART(UxCTL, UxTCTL, UxRCTL, UxMCTL, UxBR0, UxBR1, UxRXBUF,UxTXBUF)：UxCTL:控制寄存器，PUC: 001H76543210PENAPEVSPBCHARLISTENSYNCMMSWRSTPENA: Parity enable. 0:Disable, 1: EnablePEV:Parity select. 0...
ｌｉｎｕｘ之UART
一只拖鞋
04-08 1117
概述linux下设备分几种：    1.协议类：UART,I2C,SPI,NAND,LCD    2.类似内存的接口：NOR,SDRAM,网卡    针对协议类设备,那么需要满足２个要求：    1.双方约定信号的协议    2.双方满足时序的要求一．UART原理简介        通用异步收发器简称UART，即Universal Asynchronous Receiver/Transmitter...
模拟串口UART的实现
热门推荐
瞅瞅水的博客
06-04 1万+
我所祷告的，就是要你们的爱心，在知识和见识上，多而又多，使你们能分辨是非，做诚实无过的人，直到基督的日子。——腓立比书【1:9~10】最近在调的MCU的型号为STM32F030，配置芯片相较之前的MCU都比较简单，功能配置很顺利。但是在写串口程序的时候，发现串口一直不通，使用示波器也没有波形。因为基本的串口通讯线只有Tx和Rx两根线，配置也相对简单，8位数位，1位停止位，9600波特率。协议结构为...
嵌入式Linux如何用C读写uart
04-06
在嵌入式Linux中，可以使用C语言来读写UART串口。以下是一个基本的读写UART的代码示例： ```c #include <stdio.h> #include <fcntl.h> #include <termios.h> int main() { int fd; struct termios options; // 打开串口 fd = open("/dev/ttyS0", O_RDWR | O_NOCTTY | O_NDELAY); // 设置串口属性 tcgetattr(fd, &options); cfsetispeed(&options, B9600); cfsetospeed(&options, B9600); options.c_cflag |= (CLOCAL | CREAD); options.c_cflag &= ~PARENB; options.c_cflag &= ~CSTOPB; options.c_cflag &= ~CSIZE; options.c_cflag |= CS8; tcsetattr(fd, TCSANOW, &options); // 写入数据 char msg[] = "Hello, UART!"; write(fd, msg, sizeof(msg)); // 读取数据 char buf[255]; int n = read(fd, buf, sizeof(buf)); if (n > 0) { printf("Received data: %s\n", buf); } // 关闭串口 close(fd); return 0; } ``` 在上面的代码中，首先通过`open()`函数打开了`/dev/ttyS0`串口设备文件，并设置了串口的属性，包括波特率、数据位、停止位、校验位等。然后使用`write()`函数向串口写入数据，使用`read()`函数从串口读取数据。最后使用`close()`函数关闭串口。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值