Linux下读取RFID卡号(C串口编程)

由于项目需要用到RFID、GPRS、摄像头等模块所以便看了一下，整理了一下学习思路，本篇先是整理一下串口读取RFID卡号的程序思路，后面还会更其他的得意奋斗

RFID模块：

    本次采用的是125K的RFID读卡器和标签，很容易理解的，其实就是一张卡片里面存了一串数字(这个问题有点像你问一个艺术家洛必达法则是啥再见咦洛必达是啥)，然后有个读卡器，当你把卡片放到读卡器上时，读卡器会将卡里面存的卡号读取出来，然后放到串口发送缓冲区，等待我们去读取，那么问题就是怎么读取。

串口读写：

    大家都知道。linux下面一切皆文件，设备也不例外，上面提到的串口就是个设备文件，linux设备文件一般存放在“/dev/”下，当你ls的时候会发现一大堆什么ttyS0、sda、video....现在笔记本串口设备文件一般都是ttyUSBx(x=0,1,2...)。既然是文件，那就能打开喽，不过它不是被“右键->打开”，而是被“系统调用open()”。当然不只是把它打开就完了，操作串口有一系列的系统调用。说到系统调用，其实就是系统底层给在上层编写程序的你提供的一些系统级函数。

    一些需要的头文件：

[cpp] view plain copy
  1. #include <unistd.h>       /*linux系统调用*/  
  2. #include <stdlib.h>  
  3. #include <stdio.h>  
  4. #include <string.h>  
  5. #include <fcntl.h>        /*文件控制*/  
  6. #include <sys/stat.h>     /*文件状态*/  
  7. #include <sys/types.h>    /*定义系统类型，像size_t等*/  
  8. #include <errno.h>        /*出错码*/  
  9. #include <termios.h>      /*终端参数*/  


   1.打开串口

    这里把open()这个系统调用封装成一个com_open()函数，可以方便判断是否打开成功并打印错误信息。

    参数*DEV是文件路径(上面提到的/dev/ttyUSBx),第二个参数告诉它是以什么方式打开，常见的有：

    O_RDONLY 只读

    O_WRONLY 只写

    O_RDWR 读写

    注：上面的三个不能同时出现，即不能这样写O_RDONLY | O_RDWR，像下面这些是可选的：

   O_NOCTTY 如果路径名指向终端设备，不要把这个设备用作控制终端。

   O_NONBLOCK 阻塞模式(详见配置串口处)

    open()返回值是int型fd文件描述符，const char *DEV)  

  • {  
  •     int fd = -1;  
  •     open(DEV, O_RDWR);  
  •     if(fd == -1)  
  •     {  
  •         perror("open error");  
  •         exit(0);  
  •     }  
  •     return fd;  
  • }  

    2.配置串口

    设置串口属性(类似于约定好双方通信协议)，即上面提到的配置串口，其实主要就是设置termios.h中的termios结构体参数：

[cpp] view plain copy
  1. typedef struct com_attr       /*我自己定义的串口属性结构*/           
  2. {  
  3.     unsigned int baudrate;    /*波特率*/  
  4.     unsigned char databits;    /*数据位*/  
  5.     unsigned char stopbits;    /*停止位*/  
  6.     unsigned char parity;    /*校验位*/  
  7. }com_attr;  
[cpp] view plain copy
  1. struct termios          /*termios结构，其实终极目的就是把我们自己定义的结构属性设置到这里面去*/  
  2. {  
  3.    tcflag_t  c_iflag;   //输入模式标志  
  4.    tcflag_t  c_oflag;  //输出模式标志  
  5.    tcflag_t  c_cflag;  //控制模式标志  
  6.    tcflag_t  c_lflag;   //本地模式标志  
  7.    cc_t   c_line;              //line discipline  
  8.    cc_t   c_cc[NCC];    //control characters  
  9. }  

    可以看到两个参数，第一个文件描述符，告诉它你想在个文件操作，第二个是我定义的串口属性结构体：

    注：由于项目需要，可能有些不必要的参数我就没有去设置和解释，详细可以google一下配置串口属性结构体详细介绍！

[cpp] view plain copy
  1. int set_com_attr(int fd, com_attr *attr)  
  2. {  
  3.     struct termios opt;  
  4.     memset(&opt, 0, sizeof(struct termios));  
  5.     tcgetattr(fd, &opt);  
  6.     cfmakeraw(&opt);      
  7.       
  8.       
  9.     /*******************波特率********************/  
  10.     printf("set baudrate %d\n", attr->baudrate);  
  11.     switch (attr->baudrate)  
  12.     {  
  13.         case 50:  
  14.             cfsetispeed(&opt, B50);  
  15.             cfsetospeed(&opt, B50);  
  16.             break;  
  17.         case 75:  
  18.             cfsetispeed(&opt, B75);  
  19.             cfsetospeed(&opt, B75);  
  20.             break;  
  21.         case 110:  
  22.             cfsetispeed(&opt, B110);  
  23.             cfsetospeed(&opt, B110);  
  24.             break;  
  25.         case 134:  
  26.             cfsetispeed(&opt, B134);  
  27.             cfsetospeed(&opt, B134);  
  28.             break;  
  29.         case 150:  
  30.             cfsetispeed(&opt, B150);  
  31.             cfsetospeed(&opt, B150);  
  32.             break;  
  33.         case 200:  
  34.             cfsetispeed(&opt, B200);  
  35.             cfsetospeed(&opt, B200);  
  36.             break;  
  37.         case 300:  
  38.             cfsetispeed(&opt, B300);  
  39.             cfsetospeed(&opt, B300);  
  40.             break;  
  41.         case 600:  
  42.             cfsetispeed(&opt, B600);  
  43.             cfsetospeed(&opt, B600);  
  44.             break;  
  45.         case 1200:  
  46.             cfsetispeed(&opt, B1200);  
  47.             cfsetospeed(&opt, B1200);  
  48.             break;  
  49.         case 1800:  
  50.             cfsetispeed(&opt, B1800);  
  51.             cfsetospeed(&opt, B1800);  
  52.             break;  
  53.         case 2400:  
  54.             cfsetispeed(&opt, B2400);  
  55.             cfsetospeed(&opt, B2400);  
  56.             break;  
  57.         case 4800:  
  58.             cfsetispeed(&opt, B4800);  
  59.             cfsetospeed(&opt, B4800);  
  60.             break;  
  61.         case 9600:  
  62.             cfsetispeed(&opt, B9600);  
  63.             cfsetospeed(&opt, B9600);  
  64.             break;  
  65.         case 19200:  
  66.             cfsetispeed(&opt, B19200);  
  67.             cfsetospeed(&opt, B19200);  
  68.             break;  
  69.         case 38400:  
  70.             cfsetispeed(&opt, B38400);  
  71.             cfsetospeed(&opt, B38400);  
  72.             break;  
  73.         case 57600:  
  74.             cfsetispeed(&opt, B57600);  
  75.             cfsetospeed(&opt, B57600);  
  76.             break;  
  77.         case 115200:  
  78.             cfsetispeed(&opt, B115200);  
  79.             cfsetospeed(&opt, B115200);  
  80.             break;  
  81.         case 230400:  
  82.             cfsetispeed(&opt, B230400);  
  83.             cfsetospeed(&opt, B230400);  
  84.             break;  
  85.         case 460800:  
  86.             cfsetispeed(&opt, B460800);  
  87.             cfsetospeed(&opt, B460800);  
  88.             break;  
  89.         case 500000:  
  90.             cfsetispeed(&opt, B500000);  
  91.             cfsetospeed(&opt, B500000);  
  92.             break;  
  93.         case 576000:  
  94.             cfsetispeed(&opt, B576000);  
  95.             cfsetospeed(&opt, B576000);  
  96.             break;  
  97.         case 921600:  
  98.             cfsetispeed(&opt, B921600);  
  99.             cfsetospeed(&opt, B921600);  
  100.             break;  
  101.         case 1000000:  
  102.             cfsetispeed(&opt, B1000000);  
  103.             cfsetospeed(&opt, B1000000);  
  104.             break;  
  105.         case 1152000:  
  106.             cfsetispeed(&opt, B1152000);  
  107.             cfsetospeed(&opt, B1152000);  
  108.             break;  
  109.         case 1500000:  
  110.             cfsetispeed(&opt, B1500000);  
  111.             cfsetospeed(&opt, B1500000);  
  112.             break;  
  113.         case 2000000:  
  114.             cfsetispeed(&opt, B2000000);  
  115.             cfsetospeed(&opt, B2000000);  
  116.             break;  
  117.         case 2500000:  
  118.             cfsetispeed(&opt, B2500000);  
  119.             cfsetospeed(&opt, B2500000);  
  120.             break;  
  121.         case 3000000:  
  122.             cfsetispeed(&opt, B3000000);  
  123.             cfsetospeed(&opt, B3000000);  
  124.             break;  
  125.         case 3500000:  
  126.             cfsetispeed(&opt, B3500000);  
  127.             cfsetospeed(&opt, B3500000);  
  128.             break;  
  129.         case 4000000:  
  130.             cfsetispeed(&opt, B4000000);  
  131.             cfsetospeed(&opt, B4000000);  
  132.             break;  
  133.         default:  
  134.             printf("unsupported baudrate %d\n", attr->baudrate);  
  135.             return FALSE;  
  136.             break;  
  137.     }  
  138.   
  139.   
  140.     /************************校验位************************/  
  141.     switch (attr->parity)  
  142.     {  
  143.         case COMM_NOPARITY:       
  144.             opt.c_cflag &= ~PARENB;   
  145.             opt.c_iflag &= ~INPCK;    
  146.             break;  
  147.         case COMM_ODDPARITY:          
  148.             opt.c_cflag |= PARENB;    
  149.             opt.c_cflag |= PARODD;    
  150.             opt.c_iflag |= INPCK;     
  151.             break;  
  152.         case COMM_EVENPARITY:         
  153.             opt.c_cflag |= PARENB;    
  154.             opt.c_cflag &= ~PARODD;   
  155.             opt.c_iflag |= INPCK;     
  156.         default:  
  157.             printf("unsupported parity %d\n", attr->parity);  
  158.             return FALSE;  
  159.             break;  
  160.     }  
  161.             opt.c_cflag &= ~CSIZE;       /*无论设置多少校验位都需要的*/  
  162.       
  163.   
  164.         /*******************数据位*****************/  
  165.     switch (attr->databits)                
  166.     {  
  167.         case 5:  
  168.             opt.c_cflag |= CS5;  
  169.             break;  
  170.         case 6:  
  171.             opt.c_cflag |= CS6;  
  172.             break;  
  173.         case 7:  
  174.             opt.c_cflag |= CS7;  
  175.             break;  
  176.         case 8:  
  177.             opt.c_cflag |= CS8;  
  178.             break;  
  179.         default:  
  180.             printf("unsupported data bits %d\n", attr->databits);  
  181.             return FALSE;  
  182.             break;  
  183.     }  
  184.     opt.c_cflag &= ~CSTOPB;  
  185.   
  186.   
  187.     /*******************停止位***************/  
  188.     switch (attr->stopbits)         
  189.     {  
  190.         case COMM_ONESTOPBIT:  
  191.             opt.c_cflag &= ~CSTOPB;  
  192.             break;  
  193.   
  194.         case COMM_TWOSTOPBITS:  
  195.             opt.c_cflag |= CSTOPB;  
  196.             break;  
  197.         default:  
  198.             printf("unsupported stop bits %d\n", attr->stopbits);  
  199.             return FALSE;  
  200.             break;  
  201.     }  
  202.   
  203.   
  204.     /*等待时间,阻塞模式下设置的*/  
  205.     //opt.c_cc[VTIME]   = 0;    /*设置超时时间*/  
  206.     //opt.c_cc[VMIN]    = 1;      
  207.   
  208.   
  209.     opt.c_iflag &= ~(ICRNL | INLCR);  
  210.     opt.c_iflag &= ~(IXON | IXOFF | IXANY);/*关闭软件流控(一般都是关闭软硬流控，我也不知道为啥)*/  
  211.   
  212.   
  213.     tcflush(fd, TCIOFLUSH);        //刷清缓冲区  
  214.     if (tcsetattr(fd, TCSANOW, &opt) < 0)  
  215.     {  
  216.         printf("tcsetattr faild\n");  
  217.         return FALSE;  
  218.     }  
  219.     return TRUE;  
  220. }  

    当以阻塞模式打开时也可以通过修改结构体termios来改变位非阻塞模式或者通过函数fcntl()函数：

    阻塞：fcntl(fd, F_SETFL, 0)

    对于read，阻塞指当串口输入缓冲区没有数据的时候，read函数将会阻塞在这里，直到串口输入缓冲区中有数据可读取时read读到了需要的字节数之后，返回值为读到的字节数；对于write，指当串口输出缓冲区满或剩下的空间小于将要写入的字节数，write函数将阻塞在这里，一直到串口输出缓冲区中剩下的空间大于等于将要写入的字节数，执行写入操作，返回写入的字节数。

    注：控制符VTIME定义要等待的时间t(百毫秒)，VMIN定义了要等待的最小字节数n，以下几种情况：
    VTIME=0，VMIN=n，read必须在读取了VMIN个字节的数据或者收到一个信号才会返回。
    VTIME=t，VMIN=0，不管能否读取到数据，read也要等待VTIME的时间量。
    VTIME=t，VMIN=n，那么将从read读取第一个字节的数据时开始计时，并会在读取到VMIN个字节或者VTIME时间后返回。
    VTIME=0，VMIN=0，不管能否读取到数据，read都会立即返回。

    非阻塞的定义：fcntl(fd, F_SETFL,FNDELAY)

    当串口输入缓冲区没有数据的时候，read函数立即返回，返回值为0。

[cpp] view plain copy
  1. void get_com_attr(int fd)  
  2. {  
  3.     struct termios opt;  
  4.     if(fd < 0)  
  5.     {  
  6.         printf("get_com_attr error");  
  7.         exit(0);  
  8.     }  
  9.     memset(&opt, 0, sizeof(struct termios));  
  10.     tcgetattr(fd, &opt);  
  11.     cfmakeraw(&opt);  
  12. }   

    有必要说一下int tcsetattr(int fd, int optional_actions, const struct termios *termios_p)

                            int tcgetattr(int fd, struct termios *termios_p)

    tcgetattr函数用于获取与终端相关的参数。参数fd为终端的文件描述符，结果保存在termios结构体中。

    tcsetattr函数用于设置终端的相关参数。参数optional_actions用于控制修改起作用的时间，而结构体termios_p中保存了要修改的参数；

    optional_actions可以取如下的值：
    TCSANOW：不等数据传输完毕就立即改变属性。
    TCSADRAIN：等待所有数据传输结束才改变属性。
    TCSAFLUSH：清空输入输出缓冲区才改变属性。

   3.读取串口

    这里也是将read()系统调用封装成com_read()，当我们设置好通讯协议了(串口属性)，就可以对串口进行读写了。

    参数一fd就不用说了，第二个参数read_buff从名字看出就是要把数据读到这个缓冲区中，第三个参数是你想要读多少字节，注意是”你想要“，而返回值则是读到的真正字节数，当你读到末尾(假如缓冲区有10个字节，而你想要读20个)或者出现异常中断了读操作，就会出现返回值ret(return) != nbytes。

[cpp] view plain copy
  1. int com_read(int fd, unsigned char *read_buff, unsigned int nbytes)  
  2. {  
  3.     int ret;  
  4.     if(fd < 0)  
  5.     {  
  6.         printf("com_read error");  
  7.         exit(0);  
  8.     }  
  9.         ret = read(fd, read_buff, nbytes);  
  10.     return ret;  
  11. }  

    4.写入串口

    道理和写差不多

[cpp] view plain copy
  1. int com_write(int fd, BYTE *write_buff, DWORD nbytes)  
  2. {  
  3.     int ret;  
  4.     if(fd < 0)  
  5.     {  
  6.         printf("com_write error");  
  7.         exit(0);  
  8.     }  
  9.     ret = write(fd, write_buff, nbytes);  
  10.     return ret;  
  11. }  

    5.关闭串口

    记得每次操作完串口要关闭串口(当然了，当你操作多个文件时可别操作错了文件描述符，那就gg了)

[cpp] view plain copy
  1. void com_close(int fd)  
  2. {  
  3.     if(fd < 0)  
  4.     {  
  5.         printf("com_close error");  
  6.         exit(0);  
  7.     }  
  8.     close(fd);  
  9. }  


    好了，万事具备,下面就可以插上设备刷卡读卡号啦(注意看清你的设备ttyUSBx中的x是多少啊)，具体读卡号函数就看大家的具体需求啦。

    由于博主的项目需求是要将卡号变成一个字符串然后再填充到另一个字符串，然后再巴拉巴拉，可是这个卡号读出来是一串16进制数据，所以想了半天决定用类型转换(不过听说可以用fprintf)。

posted @ 2017-11-04 11:03  专注it  阅读(2514)  评论(0)  编辑  收藏  举报