在ARM Linux应用层下驱动MFRC522

1、媒介

本文将介绍怎样在ARM Linux应用层下，利用SPI驱动MFRC522读写IC-S50。本人也是第一次接触MFRC522，所以本文将记录概念扫盲到最终的驱动实现。
2、IC卡 和 IC卡读卡器

IC卡一般分为接触式IC卡和非接触式IC卡。所以实际上我们将讨论的是非接触式IC卡和非接触式IC卡读卡器。IC卡里是有一个芯片的，IC卡读卡器也是有一个芯片的，很多半导体公司都有生产用于IC卡和IC卡读卡器的芯片。所以再细分下来，我们将讨论的是NXP公司生产的MIFARE Classic系列的S50型号的非接触式卡IC芯片（后文将称为IC-S50）和NXP公司生产的MFRC522非接触式读卡器芯片。它们都工作于13.56MHz。
例如下图是一个利用了MFRC522芯片的读卡器模块，本次实验也是利用这个模块：

下图是利用了IC-S50的非接触式IC卡，右边白色IC卡的物理外观遵循国际标准ISO/IEC 7816，和我们通常利用的银行卡、校园卡的外观是一样的（也可以称M1卡）。其它外观的另有像左边蓝色这种的，常见于门禁等多种场合。

非接触式IC卡通过无线射频（RF）与读卡器通信。它们通常遵循ISO/IEC 14443标准，工作频率为13.56MHz。非接触式IC卡不必要外部电源。它们通过感应天线从读卡器的射频信号中获取能量，这种能量足以驱动卡片内的芯片举行数据处置惩罚和通信。如下图为MFRC522和IC卡通信示意框图：

下面我们将进一步相识IC-S50和MFRC522的根本特性。
IC-S50根本特性：

• 8KBit大小的EEPROM存储
  
• 分为16个扇区，每个扇区为4块，每块16字节，以块为存取单位
  
• 每个扇区有独立的一组密码及访问控制
  
• 每张卡有唯一序列号，为 32 位
  
• 工作频率：13.56MHZ
  
• 通信速率：106 KBPS
  
• 读写距离：10 cm 以内（与读写器有关）
  

MFRC522根本特性：

• 支持的主机接口：SPI、UART、I2C
  
• 支持ISO 14443A / MIFARE
  

3、MFRC522

这里实际必要相识两个芯片的利用，分别是MFRC522和IC-S50。MFRC522重要相识的内容有两部分，分别是MFRC522寄存器集 和 MFRC522命令集。
3.1、寄存器集

MFRC522有4组寄存器，分别如下所示。
Page 0（命令和状态寄存器）：

Page 1（命令寄存器）：

Page 2（配置寄存器）：

Page 3（测试寄存器）：

3.2、命令集

MFRC522的利用由可执行一系列命令的内部状态机来决定。通过向寄存器集中的命令寄存器写入相应的命令来启动命令。下图是MFRC522的命令集：

3.3、数据利用

这里利用的MFRC522模块是SPI接口。
对于读数据（MSB先行）：

对于写数据（MSB先行）：

其中对于地址字节有如下要求：地址字节的最高位bit7为1时表示从MFRC522读取数据，为0时表示向MFRC522写入数据。bit6-bit1表示地址。bit0为0。

3.4、基础函数编写

关于MFRC522的利用教程博客有很多。这里保举直接参考野火基于stm32的MFRC522驱动。我们先以读取到IC卡的ID为阶段性目的，以此测试spi和mfrc522相关的基础函数是正常的。
如今还没介绍IC-S50，又怎样知道怎么读ID？没关系，先复制粘贴。由于关于mfrc522的利用函数太多了，先移植一部分。
3.4.1、MFRC522接线

MFRC522Linux板卡SDA（片选脚）任意gpio口MOSISPI_MISOMISOSPI_MOSISCK（时钟脚）SPI_CLKRST（复位脚）任意gpio口3.3V3.3VGNDGND 3.4.2、编写SPI利用函数

下面将直接提供在Linux应用层的spi利用函数，支持多线程下利用。也可以用在其它项目。
spi.h：

1. /* spi.h */
3. #ifndef _SPI_H
4. #define _SPI_H
6. #include <sys/types.h>
7. #include <sys/stat.h>
8. #include <sys/ioctl.h>
9. #include <stdlib.h>
10. #include <fcntl.h>
11. #include <unistd.h>
12. #include <stdio.h>
13. #include <string.h>
14. #include <gpiod.h>
15. #include <stdint.h>
16. #include <linux/spi/spidev.h>
17. #include <pthread.h>
19. typedef struct spi_handle
20. {
21.         char *dev_name;
22.         int fd;       
23.         pthread_mutex_t mutex;
24.         struct gpiod_chip *cs_gpiochip;        
25.         struct gpiod_line *cs_gpioline;
26. }spi_handle_t;
28. typedef enum
29. {
30.         SPIMODE0 = SPI_MODE_0,
31.         SPIMODE1 = SPI_MODE_1,
32.         SPIMODE2 = SPI_MODE_2,
33.         SPIMODE3 = SPI_MODE_3,
34. }SPI_MODE;
36. typedef enum
37. {
38.     S_1M    = 1000000,
39.         S_6_75M = 6750000,
40.         S_8M    = 8000000,
41.         S_13_5M = 13500000,
42.         S_27M   = 27000000,
43. }SPI_SPEED;
45. spi_handle_t *spi_handle_alloc(const char *spi_dev, SPI_MODE spi_mode, SPI_SPEED spi_speed, const char *cs_chip, unsigned int cs_num);
46. void spi_write_and_read(spi_handle_t *spi, unsigned char *send_buf, unsigned int send_buf_len, unsigned char *recv_buf);
47. void spi_write_then_read(spi_handle_t *spi, unsigned char *send_buf, unsigned int send_buf_len, unsigned char *recv_buf, unsigned int recv_buf_len);
48. void spi_write_byte_data(spi_handle_t *spi, unsigned char data);
49. void spi_write_nbyte_data(spi_handle_t *spi, unsigned char *send_buf, unsigned int send_buf_len);
50. void spi_handle_free(spi_handle_t *spi);
52. #endif

复制代码

spi.c：

1. /* spi.c */
3. #include "spi.h"
5. /*******************************
6. * @brief : SPI同时发送数据和接收数据
7. * @param : spi - SPI设备句柄
8. *          send_buf - 发送缓冲区
9. *          send_buf_len - 发送缓冲区长度
10. *          recv_buf - 接收缓冲区
11. * @return: 无
12. *******************************/
13. void spi_write_and_read(spi_handle_t *spi, unsigned char *send_buf, unsigned int send_buf_len, unsigned char *recv_buf)
14. {
15.         struct spi_ioc_transfer        xfer[1];
16.         int status;
17.        
18.     if (spi == NULL)
19.         return;
21.     if (send_buf == NULL || recv_buf == NULL)
22.         return;
24.     memset(xfer, 0, sizeof(xfer));
26.         xfer[0].tx_buf = (unsigned long)send_buf;
27.         xfer[0].rx_buf = (unsigned long)recv_buf;
28.         xfer[0].len = send_buf_len;
29.        
30.     pthread_mutex_lock(&(spi->mutex));
32.     gpiod_line_set_value(spi->cs_gpioline, 0);
34.         status = ioctl(spi->fd, SPI_IOC_MESSAGE(1), xfer);
35.         if (status < 0)
36.         printf("SPI_IOC_MESSAGE failed!\n");
38.     gpiod_line_set_value(spi->cs_gpioline, 1);
40.     pthread_mutex_unlock(&(spi->mutex));
41. }
43. /*******************************
44. * @brief : SPI先发送数据后接收数据
45. * @param : spi - SPI设备句柄
46. *          send_buf - 发送缓冲区
47. *          send_buf_len - 发送缓冲区长度
48. *          recv_buf - 接收缓冲区
49. *          recv_buf_len - 接收缓冲区长度
50. * @return: 无
51. *******************************/
52. void spi_write_then_read(spi_handle_t *spi, unsigned char *send_buf, unsigned int send_buf_len, unsigned char *recv_buf, unsigned int recv_buf_len)
53. {
54.     struct spi_ioc_transfer        xfer[2];
55.         int status;
57.     if (spi == NULL)
58.         return;
60.     if (send_buf == NULL || recv_buf == NULL)
61.         return;
63.     memset(xfer, 0, sizeof(xfer));
65.         xfer[0].tx_buf = (unsigned long)send_buf;
66.         xfer[0].len = send_buf_len;
68.         xfer[1].rx_buf = (unsigned long)recv_buf;
69.         xfer[1].len = recv_buf_len;
71.     pthread_mutex_lock(&(spi->mutex));
73.     gpiod_line_set_value(spi->cs_gpioline, 0);
75.         status = ioctl(spi->fd, SPI_IOC_MESSAGE(2), xfer);
76.         if (status < 0)
77.         printf("SPI_IOC_MESSAGE failed!\n");
79.     gpiod_line_set_value(spi->cs_gpioline, 1);
81.     pthread_mutex_unlock(&(spi->mutex));
82. }
84. /*******************************
85. * @brief : SPI发送一个字节
86. * @param : spi - SPI设备句柄
87. *          data - 待发送的字节数据
88. * @return: 无
89. *******************************/
90. void spi_write_byte_data(spi_handle_t *spi, unsigned char data)
91. {
92.     unsigned char buff[1] = {data};
94.     if (spi == NULL)
95.         return;
97.     pthread_mutex_lock(&(spi->mutex));
99.     gpiod_line_set_value(spi->cs_gpioline, 0);
101.     write(spi->fd, &buff, 1);
103.     gpiod_line_set_value(spi->cs_gpioline, 1);
105.     pthread_mutex_unlock(&(spi->mutex));
106. }
108. /*******************************
109. * @brief : 通过SPI发送多个字节数据
110. * @param : spi - SPI设备句柄
111. *          send_buf - 发送缓冲区
112. *          send_buf_len - 发送缓冲区长度
113. * @return: 无
114. *******************************/
115. void spi_write_nbyte_data(spi_handle_t *spi, unsigned char *send_buf, unsigned int send_buf_len)
116. {
117.     struct spi_ioc_transfer        xfer[2];
118.     unsigned char recv_buf[send_buf_len];
119.         int status;
121.     if (spi == NULL)
122.         return;
124.     if (send_buf == NULL)
125.         return;
127.     memset(xfer, 0, sizeof(xfer));
128.     memset(recv_buf, 0, sizeof(send_buf_len));
130.         xfer[0].tx_buf = (unsigned long)send_buf;
131.     xfer[0].rx_buf = (unsigned long)recv_buf;
132.         xfer[0].len = send_buf_len;
134.     pthread_mutex_lock(&(spi->mutex));
136.     gpiod_line_set_value(spi->cs_gpioline, 0);
138.         status = ioctl(spi->fd, SPI_IOC_MESSAGE(1), xfer);
139.         if (status < 0)
140.         printf("SPI_IOC_MESSAGE failed!\n");
142.     gpiod_line_set_value(spi->cs_gpioline, 1);
144.     pthread_mutex_unlock(&(spi->mutex));
145. }
147. /*******************************
148. * @brief : 分配并初始化SPI设备句柄
149. * @param : spi_dev - SPI设备文件路径
150. *          spi_mode - SPI模式
151. *          spi_speed - SPI通信速度
152. *          cs_chip - 片选GPIO芯片      
153. *          cs_line - 片选GPIO引脚
154. * @return: 成功返回SPI设备句柄，失败返回NULL
155. *******************************/
156. spi_handle_t *spi_handle_alloc(const char *spi_dev, SPI_MODE spi_mode, SPI_SPEED spi_speed, const char *cs_chip, unsigned int cs_line)
157. {
158.     int ret;
159.     int fd;
160.     char spi_bits = 8;
161.     SPI_SPEED speed = (uint32_t)spi_speed;
163.     if (!spi_dev)
164.         return NULL;
166.     if (!cs_chip)
167.         return NULL;
168.    
169.     fd = open(spi_dev, O_RDWR);
170.         if (fd < 0)
171.     {
172.                 printf("open %s failed!\n", spi_dev);
173.                 return NULL;
174.         }
176.     /* alloc spi_handle_t */
177.     spi_handle_t *spi = (spi_handle_t *)malloc(sizeof(spi_handle_t));
178.     if (!spi)
179.     {
180.         printf("spi_handle_t allocation failed!\n");
181.         return NULL;
182.     }
183.     spi->fd = fd;
185.     /* spi mode setting */
186.     ret = ioctl(spi->fd, SPI_IOC_WR_MODE, &spi_mode);               
187.     if (ret < 0)
188.     {
189.                 printf("SPI_IOC_WR_MODE failed!\n");
190.                 free(spi);
191.                 return NULL;
192.         }
194.     /* bits per word */
195.     ret = ioctl(spi->fd, SPI_IOC_WR_BITS_PER_WORD, &spi_bits);   
196.     if (ret < 0)
197.     {
198.                 printf("SPI_IOC_WR_BITS_PER_WORD failed!\n");
199.                 free(spi);
200.                 return NULL;
201.         }
203.     /* spi speed setting */
204.     ret = ioctl(spi->fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);        
205.     if (ret < 0)
206.     {
207.                 printf("SPI_IOC_WR_MAX_SPEED_HZ failed!\n");
208.                 free(spi);
209.                 return NULL;
210.         }
212.     spi->dev_name = (char *)malloc(strlen(spi_dev) + 1);
213.     if (!(spi->dev_name))
214.     {
215.         printf("dev_name allocation failed!\n");
216.         free(spi);
217.         return NULL;
218.     }
219.     strcpy(spi->dev_name, spi_dev);
221.     ret = pthread_mutex_init(&spi->mutex, NULL);
222.     if (ret != 0)
223.     {
224.         printf("pthread_mutex_init failed!\n");
225.         free(spi->dev_name);
226.         free(spi);
227.         return NULL;
228.     }
230.     /* cs pin init */
231.     spi->cs_gpiochip = gpiod_chip_open(cs_chip);
232.     if (spi->cs_gpiochip == NULL)
233.     {
234.         printf("gpiod_chip_open failed!\n");
235.         free(spi->dev_name);
236.         free(spi);
237.         return NULL;
238.     }
239.     spi->cs_gpioline = gpiod_chip_get_line(spi->cs_gpiochip, cs_line);
240.     if (spi->cs_gpioline == NULL)
241.     {
242.         printf("gpiod_chip_get_line failed!\n");
243.         free(spi->dev_name);
244.         free(spi);
245.         return NULL;
246.     }
247.     ret = gpiod_line_request_output(spi->cs_gpioline, "cs_gpioline", 1);
248.     if (ret < 0)
249.     {
250.         printf("gpiod_line_request_output failed!\n");
251.         free(spi->dev_name);
252.         free(spi);
253.         return NULL;
254.     }
256.     return spi;
257. }
259. /*******************************
260. * @brief : 释放SPI设备句柄
261. * @param : spi - SPI设备句柄
262. * @return: 无
263. *******************************/
264. void spi_handle_free(spi_handle_t *spi)
265. {
266.     if (!spi)
267.         return;
269.     gpiod_line_release(spi->cs_gpioline);
270.     gpiod_chip_close(spi->cs_gpiochip);
272.     if (spi->dev_name)
273.     {
274.         free(spi->dev_name);
275.     }
277.     pthread_mutex_destroy(&spi->mutex);
279.     free(spi);
280. }

复制代码

3.4.3、编写MFRC522基础函数

3.4.3.1、完备的mfrc522.h

本次mfrc522驱动步伐涉及两个文件，分别是mfrc522.h和mfrc522.c。如下是mfrc522.h，重要是寄存器、命令集的宏界说。注意了，这里mfrc522寄存器的宏界说命名利用驼峰命名是为了和数据手册保持同等，方便查阅：

1. /* mfrc522.h */
3. #ifndef MFRC522_H
4. #define MFRC522_H
6. #include <gpiod.h>
7. #include "spi.h"
9. #define MI_OK                                        0
10. #define MI_NOTAGERR                                1
11. #define MI_ERR                                        2
13. #define MFRC522_MAX_LEN                 18
15. /* MFRC522 REG */
16. // Page 0 - Command and Status
17. #define        RFU00                                         0x00   
18. #define        CommandReg                                    0x01   
19. #define        ComIEnReg                                     0x02   
20. #define        DivlEnReg                                     0x03   
21. #define        ComIrqReg                                     0x04   
22. #define        DivIrqReg                                     0x05
23. #define        ErrorReg                                      0x06   
24. #define        Status1Reg                                    0x07   
25. #define        Status2Reg                                    0x08   
26. #define        FIFODataReg                                   0x09
27. #define        FIFOLevelReg                                  0x0A
28. #define        WaterLevelReg                                 0x0B
29. #define        ControlReg                                    0x0C
30. #define        BitFramingReg                                 0x0D
31. #define        CollReg                                       0x0E
32. #define        RFU0F                                         0x0F
33. // Page 1 - Command
34. #define        RFU10                                         0x10
35. #define        ModeReg                                       0x11
36. #define        TxModeReg                                     0x12
37. #define        RxModeReg                                     0x13
38. #define        TxControlReg                                  0x14
39. #define        TxAutoReg                                     0x15
40. #define        TxSelReg                                      0x16
41. #define        RxSelReg                                      0x17
42. #define        RxThresholdReg                                0x18
43. #define        DemodReg                                      0x19
44. #define        RFU1A                                         0x1A
45. #define        RFU1B                                         0x1B
46. #define        MifareReg                                     0x1C
47. #define        RFU1D                                         0x1D
48. #define        RFU1E                                         0x1E
49. #define        SerialSpeedReg                                0x1F
50. // Page 2 - CFG
51. #define        RFU20                                         0x20  
52. #define        CRCResultRegM                                 0x21
53. #define        CRCResultRegL                                 0x22
54. #define        RFU23                                         0x23
55. #define        ModWidthReg                                   0x24
56. #define        RFU25                                         0x25
57. #define        RFCfgReg                                      0x26
58. #define        GsNReg                                        0x27
59. #define        CWGsCfgReg                                    0x28
60. #define        ModGsCfgReg                                   0x29
61. #define        TModeReg                                      0x2A
62. #define        TPrescalerReg                                 0x2B
63. #define        TReloadRegH                                   0x2C
64. #define        TReloadRegL                                   0x2D
65. #define        TCounterValueRegH                             0x2E
66. #define        TCounterValueRegL                             0x2F
67. // Page 3 - TestRegister
68. #define        RFU30                                         0x30
69. #define        TestSel1Reg                                   0x31
70. #define        TestSel2Reg                                   0x32
71. #define        TestPinEnReg                                  0x33
72. #define        TestPinValueReg                               0x34
73. #define        TestBusReg                                    0x35
74. #define        AutoTestReg                                   0x36
75. #define        VersionReg                                    0x37
76. #define        AnalogTestReg                                 0x38
77. #define        TestDAC1Reg                                   0x39  
78. #define        TestDAC2Reg                                   0x3A   
79. #define        TestADCReg                                    0x3B   
80. #define        RFU3C                                         0x3C   
81. #define        RFU3D                                         0x3D   
82. #define        RFU3E                                         0x3E   
83. #define        RFU3F                                                            0x3F
85. /* MFRC522 CMD */
86. #define PCD_IDLE                        0x00               // 取消当前命令
87. #define PCD_AUTHENT                     0x0E               // 验证密钥
88. #define PCD_RECEIVE                     0x08               // 接收数据
89. #define PCD_TRANSMIT                    0x04               // 发送数据
90. #define PCD_TRANSCEIVE                  0x0C               // 发送并接收数据
91. #define PCD_RESETPHASE                  0x0F               // 复位
92. #define PCD_CALCCRC                     0x03               // CRC计算
94. /* IC-S50 CMD */
95. #define PICC_REQIDL                     0x26               // 寻天线区内未进入休眠状态
96. #define PICC_REQALL                     0x52               // 寻天线区内全部卡
97. #define PICC_ANTICOLL1                  0x93               // 防冲撞
98. #define PICC_ANTICOLL2                  0x95               // 防冲撞
99. #define PICC_AUTHENT1A                  0x60               // 验证A密钥
100. #define PICC_AUTHENT1B                  0x61               // 验证B密钥
101. #define PICC_READ                       0x30               // 读块
102. #define PICC_WRITE                      0xA0               // 写块
103. #define PICC_DECREMENT                  0xC0               // 扣款
104. #define PICC_INCREMENT                  0xC1               // 充值
105. #define PICC_RESTORE                    0xC2               // 调块数据到缓冲区
106. #define PICC_TRANSFER                   0xB0               // 保存缓冲区中数据
107. #define PICC_HALT                       0x50               // 休眠
109. int mfrc522_init(const char *spi_dev,
110.     const char *cs_chip, unsigned char cs_line,
111.     const char *rst_chip, unsigned char rst_line);
112. void mfrc522_reset(void);
113. void mfrc522_antenna_on(void);
114. void mfrc522_antenna_off(void);
115. void mfrc522_config_iso_type(unsigned char type);
116. unsigned char mfrc522_to_card(unsigned char command, unsigned char *send_buf, unsigned char send_buf_len, unsigned char *recv_buf, unsigned int *recv_buf_len);
117. unsigned char mfrc522_anticoll(unsigned char* ser_num);
118. char mfrc522_pcd_request(unsigned char req_code, unsigned char *tag_type);
119. void mfrc522_exit(void);
121. #endif

复制代码

3.4.3.2、写寄存器和读寄存器

关于mfrc522基础利用函数，先实现写寄存器和读寄存器，如下：

1. /* mfrc522.c */
3. static void mfrc522_write_reg(unsigned char reg, unsigned char value)
4. {
5.     unsigned char send_buf[2];
7.     // 根据上面对地址字节的要求：
8.     // bit7为1代表读数据，为0代表写数据
9.     // bit6-bit1表示寄存器地址（寄存器只用6个bit来表示）
10.     // bit0默认为0
11.     send_buf[0] = (reg << 1) & 0x7E;
12.    
13.     send_buf[1] = value;
15.     spi_write_nbyte_data(mfrc522_spi, send_buf, sizeof(send_buf));
16. }
18. static unsigned char mfrc522_read_reg(unsigned char reg)
19. {
20.     unsigned char send_buf[2];
21.     unsigned char recv_buf[2] = {0};
23.     // 根据上面对地址字节的要求：
24.     // bit7为1代表读数据，为0代表写数据
25.     // bit6-bit1表示寄存器地址（寄存器只用6个bit来表示）
26.     // bit0默认为0
27.     send_buf[0] = ((reg << 1) & 0x7E ) | 0x80;
28.     send_buf[1] = 0x00;
30.     spi_write_and_read(mfrc522_spi, send_buf, sizeof(send_buf), recv_buf);
31.     return recv_buf[1];
32. }

复制代码

对上面两个函数再封装一下，得到如下：

1. /* mfrc522.c */
3. // 将指定寄存器中的指定位置1，其它位不变
4. static void mfrc522_set_bit_mask(unsigned char reg, unsigned char mask)
5. {
6.     unsigned char temp;
8.         temp = mfrc522_read_reg(reg);
9.     mfrc522_write_reg(reg, temp | mask);
10. }
12. // 将指定寄存器中的指定位清0，其它位不变
13. static void mfrc522_clr_bit_mask(unsigned char reg, unsigned char mask)
14. {
15.     unsigned char temp;
17.         temp = mfrc522_read_reg(reg);
18.     mfrc522_write_reg(reg, temp & (~mask));
19. }

复制代码

3.4.3.3、复位引脚利用

下面编写mfrc522复位脚的利用函数。关于复位引脚，数据手册对其的解释如下：

1. /* mfrc522.c */
3. static void mfrc522_rst_enabled(void)
4. {
5.     gpiod_line_set_value(rst_gpioline, 0);
6. }
8. static void mfrc522_rst_disabled(void)
9. {
10.     gpiod_line_set_value(rst_gpioline, 1);
11. }

复制代码

3.4.3.4、天线利用

下面是mfrc522打开天线与关闭天线的利用函数：

1. /* mfrc522.c */
3. // mfrc522打开天线
4. void mfrc522_antenna_on(void)
5. {
6.     unsigned char temp;
8.     temp = mfrc522_read_reg(TxControlReg);
9.     if (!(temp & 0x03))
10.         mfrc522_set_bit_mask(TxControlReg, 0x03);
11. }
13. // mfrc522关闭天线
14. void mfrc522_antenna_off(void)
15. {
16.     mfrc522_clr_bit_mask(TxControlReg, 0x03);
17. }

复制代码

3.4.3.5、初始化利用

下面是MFRC522的初始化和反初始化函数。分别先初始化spi、复位引脚：

1. /* mfrc522.c */
3. int mfrc522_init(const char *spi_dev,
4.                     const char *cs_chip, unsigned char cs_line,
5.                     const char *rst_chip, unsigned char rst_line)
6. {
7.     int ret;
9.     if (!spi_dev)
10.         return -1;
12.     if (!cs_chip || !rst_chip)
13.         return -1;
15.     /* spi初始化 */
16.     mfrc522_spi = spi_handle_alloc(spi_dev, SPIMODE0, S_1M, cs_chip, cs_line);
17.     if (!mfrc522_spi)
18.         return -1;
20.     /* 复位脚初始化 */
21.     rst_gpiochip = gpiod_chip_open(rst_chip);
22.     if (rst_gpiochip == NULL)
23.     {
24.         printf("gpiod_chip_open failed!\n");
25.         return -1;
26.     }
27.     rst_gpioline = gpiod_chip_get_line(rst_gpiochip, rst_line);
28.     if (rst_gpioline == NULL)
29.     {
30.         printf("gpiod_chip_get_line failed!\n");
31.         return -1;
32.     }
33.     ret = gpiod_line_request_output(rst_gpioline, "rst_gpioline", 1);
34.     if (ret < 0)
35.     {
36.         printf("gpiod_line_request_output failed!\n");
37.         return -1;
38.     }
40.     mfrc522_rst_disabled();
42.     return 0;
43. }
45. // mfrc522反初始化
46. void mfrc522_exit(void)
47. {
48.     if (mfrc522_spi)
49.         spi_handle_free(mfrc522_spi);
51.     if (rst_gpioline)
52.         gpiod_line_release(rst_gpioline);
53.     if (rst_gpiochip)
54.         gpiod_chip_close(rst_gpiochip);
55. }

复制代码

3.4.3.6、复位利用

下面是mfrc522的复位函数：

1. /* mfrc522.c */
3. void mfrc522_reset(void)
4. {
5.     mfrc522_rst_disabled();
6.     usleep(1);
8.     mfrc522_rst_enabled();                                  // 切断内部电流吸收，关闭振荡器，断开输入管脚与外部电路的连接
9.     usleep(1);
11.     mfrc522_rst_disabled();                                 // 上升沿启动内部复位阶段
12.     usleep(1);
14.     mfrc522_write_reg(CommandReg, PCD_RESETPHASE);          // 软复位
15.    
16.     while (mfrc522_read_reg(CommandReg) & 0x10)             // 等待mfrc522唤醒结束
17.         ;
18.         usleep(1);
19.    
20.     mfrc522_write_reg(ModeReg, 0x3D);                       // 定义发送和接收常用模式：和Mifare卡通讯，CRC初始值0x6363
21.    
22.     mfrc522_write_reg(TReloadRegL, 30);                     // 16位定时器低位   
23.         mfrc522_write_reg(TReloadRegH, 0);                                // 16位定时器高位
24.        
25.     mfrc522_write_reg(TModeReg, 0x8D);                                    // 定义内部定时器的设置
26.        
27.     mfrc522_write_reg(TPrescalerReg, 0x3E);                        // 设置定时器分频系数
28.        
29.         mfrc522_write_reg(TxAutoReg, 0x40);                            // 调制发送信号为100%ASK
30. }

复制代码

3.4.3.7、工作模式设置

下面是mfrc522设置工作模式的利用函数：

1. /* mfrc522.c */
3. // 设置工作模式
4. void mfrc522_config_iso_type(unsigned char type)
5. {
6.     if (type == 'A')               // ISO14443_A
7.     {
8.         mfrc522_clr_bit_mask(Status2Reg, 0x08);
10.         mfrc522_write_reg(ModeReg, 0x3D);         
12.         mfrc522_write_reg(RxSelReg, 0x86);        
14.         mfrc522_write_reg(RFCfgReg, 0x7F);         
16.         mfrc522_write_reg(TReloadRegL, 30);        
18.         mfrc522_write_reg(TReloadRegH, 0);
20.         mfrc522_write_reg(TModeReg, 0x8D);
22.         mfrc522_write_reg(TPrescalerReg, 0x3E);
23.                
24.                 usleep(2);
25.                
26.                 mfrc522_antenna_on();       //开天线
27.    }         
28. }

复制代码

3.4.3.8、和M1卡通信利用

下面是mfrc522和iso14443卡的通信函数：

1. /* mfrc522.c */
3. unsigned char mfrc522_to_card(unsigned char command, unsigned char *send_buf, unsigned char send_buf_len, unsigned char *recv_buf, unsigned int *recv_buf_len)
4. {
5.     unsigned char status = MI_ERR;
6.         unsigned char irq_en = 0x00;
7.         unsigned char wait_irq = 0x00;
8.         unsigned char last_bits;
9.         unsigned char n;
10.         unsigned int i = 0;
12.         switch (command)
13.     {
14.                 case PCD_AUTHENT:                                       // Mifare认证
15.         {
16.                         irq_en = 0x12;                                      // 允许错误中断请求ErrIEn  允许空闲中断IdleIEn
17.                         wait_irq = 0x10;                                    // 认证寻卡等待时候 查询空闲中断标志位
18.                         break;
19.                 }
20.                 case PCD_TRANSCEIVE:                                    // 接收发送 发送接收
21.         {
22.                         irq_en = 0x77;                                      // 允许TxIEn RxIEn IdleIEn LoAlertIEn ErrIEn TimerIEn
23.                         wait_irq = 0x30;                                    // 寻卡等待时候 查询接收中断标志位与 空闲中断标志位
24.                         break;
25.                 }
26.                 default:
27.                     break;
28.         }
30.         mfrc522_write_reg(ComIEnReg, irq_en | 0x80);                // IRqInv置位管脚IRQ与Status1Reg的IRq位的值相反
31.         mfrc522_clr_bit_mask(ComIrqReg, 0x80);                      // Set1该位清零时，CommIRqReg的屏蔽位清零
32.         mfrc522_write_reg(CommandReg, PCD_IDLE);                    // 写空闲命令
33.    
34.     mfrc522_set_bit_mask(FIFOLevelReg, 0x80);                   // 置位FlushBuffer清除内部FIFO的读和写指针以及ErrReg的BufferOvfl标志位被清除
36.         for (i = 0; i < send_buf_len; i++)
37.         mfrc522_write_reg(FIFODataReg, send_buf[i]);            // 写数据进FIFOdata
39.         mfrc522_write_reg(CommandReg, command);                     // 写命令
40.         if (command == PCD_TRANSCEIVE)
41.         mfrc522_set_bit_mask(BitFramingReg, 0x80);              // StartSend置位启动数据发送 该位与收发命令使用时才有效
43.         do                                                          // 认证与寻卡等待时间
44.     {
45.                 n = mfrc522_read_reg(ComIrqReg);                        // 查询事件中断
46.         usleep(1000);
47.                 i++;
48.         } while ((i != 25) && !(n & 0x01) && !(n & wait_irq));      
50.         mfrc522_clr_bit_mask(BitFramingReg, 0x80);                            // 清理允许StartSend位                                                                                                               
52.         if (i != 25)  
53.     {
54.                 if (!(mfrc522_read_reg(ErrorReg) & 0x1B))               // 读错误标志寄存器BufferOfI CollErr ParityErr ProtocolErr
55.         {
56.                         status = MI_OK;
58.                         if (n & irq_en & 0x01)                              // 是否发生定时器中断
59.                 status = MI_NOTAGERR;
61.                         if (command == PCD_TRANSCEIVE)                     
62.             {
63.                                 n = mfrc522_read_reg(FIFOLevelReg);             // 读FIFO中保存的字节数
64.                                 last_bits = mfrc522_read_reg(ControlReg) & 0x07;// 最后接收到得字节的有效位数
66.                                 if (last_bits)
67.                     *recv_buf_len = (n-1) * 8 + last_bits;      // N个字节数减去1（最后一个字节）+最后一位的位数 读取到的数据总位数
68.                 else
69.                     *recv_buf_len = n*8;                        // 最后接收到的字节整个字节有效
70.                                
71.                 if (n == 0)
72.                     n = 1;
74.                                 if (n > MFRC522_MAX_LEN)
75.                     n = MFRC522_MAX_LEN;
77.                                 for (i = 0; i < n; i++)
78.                     recv_buf[i] = mfrc522_read_reg(FIFODataReg); // 从FIFOdata读数据
79.                         }
80.                 }
81.         else
82.             status = MI_ERR;
83.         }
85.     mfrc522_set_bit_mask(ControlReg, 0x80);         
86.     mfrc522_write_reg(CommandReg, PCD_IDLE);
88.         return status;
89. }

复制代码

3.4.3.9、寻卡利用

下面是mfrc522的寻卡函数：

1. /* mfrc522.c */
3. char mfrc522_pcd_request(unsigned char req_code, unsigned char *tag_type)
4. {
5.     char status;  
6.     unsigned char com_buf[MFRC522_MAX_LEN];
7.     unsigned int len;
9.     mfrc522_clr_bit_mask(Status2Reg, 0x08);                 // 清理指示MIFARECyptol单元接通以及所有卡的数据通信被加密的情况
10.     mfrc522_write_reg(BitFramingReg, 0x07);                 // 发送的最后一个字节的 七位
11.     mfrc522_set_bit_mask(TxControlReg, 0x03);                    // TX1,TX2管脚的输出信号传递经发送调制的13.56的能量载波信号
13.     com_buf[0] = req_code;                                            // 存入卡片命令字
15.     status = mfrc522_to_card(PCD_TRANSCEIVE, com_buf, 1, com_buf, &len);        // 寻卡  
17.     if ((status == MI_OK) && (len == 0x10))                        // 寻卡成功返回卡类型
18.     {   
19.         *tag_type = com_buf[0];
20.         *(tag_type + 1) = com_buf[1];
21.     }
22.     else
23.         status = MI_ERR;
25.     return status;         
26. }

复制代码

3.4.3.10、防冲撞利用

下面是mfrc522的防冲撞函数：

1. /* mfrc522.c */
3. // 防冲撞
4. unsigned char mfrc522_anticoll(unsigned char *snr)
5. {
6.     char status;
7.     uint8_t i, snr_check = 0;
8.     uint8_t com_mfrc522_buf[MFRC522_MAX_LEN];
9.     uint32_t len;
10.    
11.     mfrc522_clr_bit_mask(Status2Reg, 0x08);             // 清MFCryptol On位 只有成功执行MFAuthent命令后，该位才能置位
12.     mfrc522_write_reg(BitFramingReg, 0x00);                    // 清理寄存器 停止收发
13.     mfrc522_clr_bit_mask(CollReg, 0x80);                        // 清ValuesAfterColl所有接收的位在冲突后被清除          
14.    
15.     com_mfrc522_buf[0] = 0x93;                                // 卡片防冲突命令
16.     com_mfrc522_buf[1] = 0x20;
17.    
18.     status = mfrc522_to_card(PCD_TRANSCEIVE, com_mfrc522_buf, 2, com_mfrc522_buf, &len);      // 与卡片通信
20.     if (status == MI_OK)                                        // 通信成功
21.     {
22.         for (i = 0; i < 4; i++)
23.         {
24.             *(snr + i) = com_mfrc522_buf[i];            // 读出UID
25.             snr_check ^= com_mfrc522_buf[i];
26.         }
27.         
28.         if (snr_check != com_mfrc522_buf[i])
29.             status = MI_ERR;                                     
30.     }
31.    
32.     mfrc522_set_bit_mask(CollReg, 0x80);
33.         
34.     return status;
35. }

复制代码

3.4.3.11、完备的mfrc522.c

好了，到目前为止，终于完成了mfrc522读IC卡 ID所必要的基础利用函数，目前完备的mfrc522.c文件如下：

1. /* mfrc522.c */
3. #include "mfrc522.h"
5. static spi_handle_t *mfrc522_spi;
6. static struct gpiod_chip *rst_gpiochip;        
7. static struct gpiod_line *rst_gpioline;
9. static void mfrc522_write_reg(unsigned char reg, unsigned char value)
10. {
11.     unsigned char send_buf[2];
13.     send_buf[0] = (reg << 1) & 0x7E;
14.     send_buf[1] = value;
16.     spi_write_nbyte_data(mfrc522_spi, send_buf, sizeof(send_buf));
17. }
19. static unsigned char mfrc522_read_reg(unsigned char reg)
20. {
21.     unsigned char send_buf[2];
22.     unsigned char recv_buf[2] = {0};
24.     send_buf[0] = ((reg << 1) & 0x7E ) | 0x80;
25.     send_buf[1] = 0x00;
27.     spi_write_and_read(mfrc522_spi, send_buf, sizeof(send_buf), recv_buf);
28.     return recv_buf[1];
29. }
31. // 将寄存器中指定的位置1
32. static void mfrc522_set_bit_mask(unsigned char reg, unsigned char mask)
33. {
34.     unsigned char temp;
36.         temp = mfrc522_read_reg(reg);
37.     mfrc522_write_reg(reg, temp | mask);
38. }
40. // 将寄存器中指定的位清0
41. static void mfrc522_clr_bit_mask(unsigned char reg, unsigned char mask)
42. {
43.     unsigned char temp;
45.         temp = mfrc522_read_reg(reg);
46.     mfrc522_write_reg(reg, temp & (~mask));
47. }
49. //
50. static void mfrc522_rst_enabled(void)
51. {
52.     gpiod_line_set_value(rst_gpioline, 0);
53. }
55. static void mfrc522_rst_disabled(void)
56. {
57.     gpiod_line_set_value(rst_gpioline, 1);
58. }
60. // mfrc522复位
61. void mfrc522_reset(void)
62. {
63.     mfrc522_rst_disabled();
64.     usleep(1);
66.     mfrc522_rst_enabled();                                  // 切断内部电流吸收，关闭振荡器，断开输入管脚与外部电路的连接
67.     usleep(1);
69.     mfrc522_rst_disabled();                                 // 上升沿启动内部复位阶段
70.     usleep(1);
72.     mfrc522_write_reg(CommandReg, PCD_RESETPHASE);          // 软复位
73.    
74.     while (mfrc522_read_reg(CommandReg) & 0x10)             // 等待mfrc522唤醒结束
75.         ;
76.         usleep(1);
77.    
78.     mfrc522_write_reg(ModeReg, 0x3D);                       // 定义发送和接收常用模式：和Mifare卡通讯，CRC初始值0x6363
79.    
80.     mfrc522_write_reg(TReloadRegL, 30);                     // 16位定时器低位   
81.         mfrc522_write_reg(TReloadRegH, 0);                                // 16位定时器高位
82.        
83.     mfrc522_write_reg(TModeReg, 0x8D);                                    // 定义内部定时器的设置
84.        
85.     mfrc522_write_reg(TPrescalerReg, 0x3E);                        // 设置定时器分频系数
86.        
87.         mfrc522_write_reg(TxAutoReg, 0x40);                            // 调制发送信号为100%ASK
88. }
90. // mfrc522打开天线
91. void mfrc522_antenna_on(void)
92. {
93.     unsigned char temp;
95.     temp = mfrc522_read_reg(TxControlReg);
96.     if (!(temp & 0x03))
97.         mfrc522_set_bit_mask(TxControlReg, 0x03);
98. }
100. // mfrc522关闭天线
101. void mfrc522_antenna_off(void)
102. {
103.     mfrc522_clr_bit_mask(TxControlReg, 0x03);
104. }
106. // 设置工作模式
107. void mfrc522_config_iso_type(unsigned char type)
108. {
109.     if (type == 'A')               // ISO14443_A
110.     {
111.         mfrc522_clr_bit_mask(Status2Reg, 0x08);
113.         mfrc522_write_reg(ModeReg, 0x3D);         
115.         mfrc522_write_reg(RxSelReg, 0x86);        
117.         mfrc522_write_reg(RFCfgReg, 0x7F);         
119.         mfrc522_write_reg(TReloadRegL, 30);        
121.         mfrc522_write_reg(TReloadRegH, 0);
123.         mfrc522_write_reg(TModeReg, 0x8D);
125.         mfrc522_write_reg(TPrescalerReg, 0x3E);
126.                
127.                 usleep(2);
128.                
129.                 mfrc522_antenna_on();       //开天线
130.    }         
131. }
133. // 通过RC522和ISO14443卡通讯
134. unsigned char mfrc522_to_card(unsigned char command, unsigned char *send_buf, unsigned char send_buf_len, unsigned char *recv_buf, unsigned int *recv_buf_len)
135. {
136.     unsigned char status = MI_ERR;
137.         unsigned char irq_en = 0x00;
138.         unsigned char wait_irq = 0x00;
139.         unsigned char last_bits;
140.         unsigned char n;
141.         unsigned int i = 0;
143.         switch (command)
144.     {
145.                 case PCD_AUTHENT:                                       // Mifare认证
146.         {
147.                         irq_en = 0x12;                                      // 允许错误中断请求ErrIEn  允许空闲中断IdleIEn
148.                         wait_irq = 0x10;                                    // 认证寻卡等待时候 查询空闲中断标志位
149.                         break;
150.                 }
151.                 case PCD_TRANSCEIVE:                                    // 接收发送 发送接收
152.         {
153.                         irq_en = 0x77;                                      // 允许TxIEn RxIEn IdleIEn LoAlertIEn ErrIEn TimerIEn
154.                         wait_irq = 0x30;                                    // 寻卡等待时候 查询接收中断标志位与 空闲中断标志位
155.                         break;
156.                 }
157.                 default:
158.                     break;
159.         }
161.         mfrc522_write_reg(ComIEnReg, irq_en | 0x80);                // IRqInv置位管脚IRQ与Status1Reg的IRq位的值相反
162.         mfrc522_clr_bit_mask(ComIrqReg, 0x80);                      // Set1该位清零时，CommIRqReg的屏蔽位清零
163.         mfrc522_write_reg(CommandReg, PCD_IDLE);                    // 写空闲命令
164.    
165.     mfrc522_set_bit_mask(FIFOLevelReg, 0x80);                   // 置位FlushBuffer清除内部FIFO的读和写指针以及ErrReg的BufferOvfl标志位被清除
167.         for (i = 0; i < send_buf_len; i++)
168.         mfrc522_write_reg(FIFODataReg, send_buf[i]);            // 写数据进FIFOdata
170.         mfrc522_write_reg(CommandReg, command);                     // 写命令
171.        
172.     if (command == PCD_TRANSCEIVE)
173.         mfrc522_set_bit_mask(BitFramingReg, 0x80);              // StartSend置位启动数据发送 该位与收发命令使用时才有效
175.         do                                                          // 认证与寻卡等待时间
176.     {
177.                 n = mfrc522_read_reg(ComIrqReg);                        // 查询事件中断
178.         usleep(1000);
179.                 i++;
180.         } while ((i != 50) && !(n & 0x01) && !(n & wait_irq));      
182.         mfrc522_clr_bit_mask(BitFramingReg, 0x80);                            // 清理允许StartSend位                                                                                                               
184.         if (i != 50)  
185.     {
186.                 if (!(mfrc522_read_reg(ErrorReg) & 0x1B))               // 读错误标志寄存器BufferOfI CollErr ParityErr ProtocolErr
187.         {
188.                         status = MI_OK;
190.                         if (n & irq_en & 0x01)                              // 是否发生定时器中断
191.                 status = MI_NOTAGERR;
193.                         if (command == PCD_TRANSCEIVE)                     
194.             {
195.                                 n = mfrc522_read_reg(FIFOLevelReg);             // 读FIFO中保存的字节数
196.                                 last_bits = mfrc522_read_reg(ControlReg) & 0x07;// 最后接收到得字节的有效位数
198.                                 if (last_bits)
199.                     *recv_buf_len = (n - 1) * 8 + last_bits;    // N个字节数减去1（最后一个字节）+最后一位的位数 读取到的数据总位数
200.                 else
201.                     *recv_buf_len = n * 8;                      // 最后接收到的字节整个字节有效
202.                                
203.                 if (n == 0)
204.                     n = 1;
206.                                 if (n > MFRC522_MAX_LEN)
207.                     n = MFRC522_MAX_LEN;
209.                                 for (i = 0; i < n; i++)
210.                     recv_buf[i] = mfrc522_read_reg(FIFODataReg); // 从FIFOdata读数据
211.                         }
212.                 }
213.         else
214.             status = MI_ERR;
215.         }
217.     mfrc522_set_bit_mask(ControlReg, 0x80);         
218.     mfrc522_write_reg(CommandReg, PCD_IDLE);
220.         return status;
221. }
223. // 防冲撞
224. unsigned char mfrc522_anticoll(unsigned char *snr)
225. {
226.     char status;
227.     uint8_t i, snr_check = 0;
228.     uint8_t com_mfrc522_buf[MFRC522_MAX_LEN];
229.     uint32_t len;
230.    
231.     mfrc522_clr_bit_mask(Status2Reg, 0x08);             // 清MFCryptol On位 只有成功执行MFAuthent命令后，该位才能置位
232.     mfrc522_write_reg(BitFramingReg, 0x00);                    // 清理寄存器 停止收发
233.     mfrc522_clr_bit_mask(CollReg, 0x80);                        // 清ValuesAfterColl所有接收的位在冲突后被清除          
234.    
235.     com_mfrc522_buf[0] = 0x93;                                // 卡片防冲突命令
236.     com_mfrc522_buf[1] = 0x20;
237.    
238.     status = mfrc522_to_card(PCD_TRANSCEIVE, com_mfrc522_buf, 2, com_mfrc522_buf, &len);      // 与卡片通信
240.     if (status == MI_OK)                                        // 通信成功
241.     {
242.         for (i = 0; i < 4; i++)
243.         {
244.             *(snr + i) = com_mfrc522_buf[i];            // 读出UID
245.             snr_check ^= com_mfrc522_buf[i];
246.         }
247.         
248.         if (snr_check != com_mfrc522_buf[i])
249.             status = MI_ERR;                                     
250.     }
251.    
252.     mfrc522_set_bit_mask(CollReg, 0x80);
253.         
254.     return status;
255. }
257. // 寻卡
258. char mfrc522_pcd_request(unsigned char req_code, unsigned char *tag_type)
259. {
260.     char status;  
261.     unsigned char com_buf[MFRC522_MAX_LEN];
262.     unsigned int len;
264.     mfrc522_clr_bit_mask(Status2Reg, 0x08);                 // 清理指示MIFARECyptol单元接通以及所有卡的数据通信被加密的情况
265.     mfrc522_write_reg(BitFramingReg, 0x07);                 // 发送的最后一个字节的 七位
266.     mfrc522_set_bit_mask(TxControlReg, 0x03);                    // TX1,TX2管脚的输出信号传递经发送调制的13.56的能量载波信号
268.     com_buf[0] = req_code;                                            // 存入卡片命令字
270.     status = mfrc522_to_card(PCD_TRANSCEIVE, com_buf, 1, com_buf, &len);        // 寻卡  
272.     if ((status == MI_OK) && (len == 0x10))                        // 寻卡成功返回卡类型
273.     {   
274.         *tag_type = com_buf[0];
275.         *(tag_type + 1) = com_buf[1];
276.     }
277.     else
278.         status = MI_ERR;
280.     return status;         
281. }
283. // mfrc522初始化
284. int mfrc522_init(const char *spi_dev,
285.                     const char *cs_chip, unsigned char cs_line,
286.                     const char *rst_chip, unsigned char rst_line)
287. {
288.     int ret;
290.     if (!spi_dev)
291.         return -1;
293.     if (!cs_chip || !rst_chip)
294.         return -1;
296.     /* spi初始化 */
297.     mfrc522_spi = spi_handle_alloc(spi_dev, SPIMODE0, S_1M, cs_chip, cs_line);
298.     if (!mfrc522_spi)
299.         return -1;
301.     /* 复位脚初始化 */
302.     rst_gpiochip = gpiod_chip_open(rst_chip);
303.     if (rst_gpiochip == NULL)
304.     {
305.         printf("gpiod_chip_open failed!\n");
306.         return -1;
307.     }
308.     rst_gpioline = gpiod_chip_get_line(rst_gpiochip, rst_line);
309.     if (rst_gpioline == NULL)
310.     {
311.         printf("gpiod_chip_get_line failed!\n");
312.         return -1;
313.     }
314.     ret = gpiod_line_request_output(rst_gpioline, "rst_gpioline", 1);
315.     if (ret < 0)
316.     {
317.         printf("gpiod_line_request_output failed!\n");
318.         return -1;
319.     }
321.     mfrc522_rst_disabled();
323.     return 0;
324. }
326. // mfrc522反初始化
327. void mfrc522_exit(void)
328. {
329.     if (mfrc522_spi)
330.         spi_handle_free(mfrc522_spi);
332.     if (rst_gpioline)
333.         gpiod_line_release(rst_gpioline);
334.     if (rst_gpiochip)
335.         gpiod_chip_close(rst_gpiochip);
336. }

复制代码

3.5、测试

下面编写一个main.c用于读取ic卡的id：

1. #include <stdio.h>
2. #include <unistd.h>
3. #include <fcntl.h>
4. #include <stdlib.h>
5. #include <pthread.h>
6. #include <gpiod.h>
7. #include <math.h>
9. #include "mfrc522.h"
11. int main()
12. {
13.     unsigned char id[4];
14.     unsigned char status;
15.     int ret;
17.     ret = mfrc522_init("/dev/spidev3.0",
18.                        "/dev/gpiochip6", 11,        // cs片选脚
19.                        "/dev/gpiochip6", 10);        // rst复位脚
20.     if (ret != 0)
21.     {
22.         printf("mfrc522_init fialed!\n");
23.         return -1;
24.     }
26.     mfrc522_reset();                                        // mfrc522复位
28.     mfrc522_config_iso_type('A');                // 设置模式
30.     while(1)
31.     {
32.         status = mfrc522_pcd_request(PICC_REQALL, id);
33.         if (status != MI_OK)
34.             printf("request card fialed!\n");
35.         else
36.             break;
38.         sleep(0.1);   
39.     }
41.     if (status == MI_OK)
42.     {
43.         printf("request card successfully!\n");
44.         if (mfrc522_anticoll(id) == MI_OK)
45.             printf("card uid = %02X%02X%02X%02X\n", id[0], id[1], id[2], id[3]);
46.     }
48.     mfrc522_exit();
49.    
50.     return 0;
51. }

复制代码

3.5.1、编译

假如利用buildroot系统，必要交叉编译。我这利用ubuntu系统，直接gcc编译。执行如下命令举行编译：

1. gcc -o build main.c spi.c mfrc522.c -lgpiod

复制代码

3.5.2、测试

执行如下命令测试：

1. sudo ./build

复制代码

和手机“NFC工具”APP读取的同等：

4、IC-S50

如今开始介绍S50芯片。
4.1、存储结构

上面介绍过，S50芯片内部有一个eeprom是用来存储数据的。容量为8Kbit，即1024Byte。分为16个扇区，即每个扇区占64Byte。每个扇区又由4个块（块0、块1、块2、块3）组成，即每个块占16Byte。如下图所示：

• 第0扇区的块0，它用于存放厂商代码，已经固化，不可更改。
  
• 每个扇区的块0、块1、块2为数据块。可以用来存放数据。数据块有两种应用：
  
  
  
  • 用作一般的数据保存，可以举行读、写利用。
    
  • 用作数据值，可以举行初始化、加值、减值、读值利用。
    
  
  
• 每个扇区的块3为尾块，存储了该扇区的访问控制信息和密钥，具体结构如下：
  

尾块的16字节分配如下：

• 字节0-5：存储Key A（密钥A），用于本扇区的访问控制。
  
• 字节6-9：存储访问控制位（Access Bits），用于界说该扇区中各块的访问权限。
  
• 字节10-15：存储Key B（密钥B），用于本扇区的访问控制。假如Key B未利用，这些字节可以作为普通数据存储。
  

这里先小结一下，总的来说就是，M1卡有16个扇区，每个扇区有4个块。我们可以通过mfrc522读卡器来访问M1卡的任意一个扇区中的任意一个块。但每个块的访问是有限制条件的，好比这个块不能读也不能写，这个块可以读但不能写等等。所以我们得清晰的知道每个块有怎样的限制。
假设如今想访问扇区1的尾块（即块3）。上面介绍过，每个扇区的尾块是用来存储KeyA、KeyB和访问控制位的，那如今想访问尾块，分析我们是想要读取或修改密码与访问控制位。所以，得看看访问尾块时，有着什么样的权限：

条件真值表由C1X3、C2X3、C3X3构成（X为某个扇区的编号。X后面的数字为块号，这里是3，代表块3），它们的值可以在尾块的Byte6-Byte9找到：

如C1X3在byte7的bit7，C2X3在byte8的bit3，C3X3在byte8的bit7。假设C1X3、C2X3、C3X3的值分别为100时，会有如下意思：

• Key A：不可读；验证Key B后可写。
  
• 控制信息：验证Key A或Key B后可读；不可写。
  
• Key B：不可读；验证Key B后可写。
  

上面介绍的是尾块的利用权限。如今再看块0~块2的利用权限：

假设如今要访问扇区2的块1。那么就要知道C121、C221、C321的值：

如C121在byte7的bit5，C221在byte8的bit1，C321在byte8的bit5。假设C121、C221、C321的值分别为100时，会有如下意思：

• 验证Key A或Key B后可读。
  
• 验证Key B后可写。
  
• 不可举行加值、减值利用。
  

4.2、M1卡与读卡器的通信流程

下图展示了M1卡与读卡器的通信流程：

• 复位应答：M1射频卡的通讯协媾和通讯波特率是界说好的，当有卡片进入读写器的利用范围时读写器以特定的协议与它通讯，从而确定该卡是否为M1射频卡，即验证卡片的卡型。
  
• 防冲突机制：当有多张卡进入读写器利用范围时，防冲突机制会从其中选择一张举行利用，未选中的则处于空闲模式等待下一次选卡，该过程会返回被选卡的序列号。
  
• 选择卡片：选择被选中的卡的序列号，并同时返回卡的容量代码。
  
• 三次相互验证：选定要处置惩罚的卡片之后，读写器就确定要访问的扇区号，并对该扇区密码举行密码校验，在三次相互认证之后就可以通过加密流举行通讯。（在选择另一扇区时，则必须举行另一扇区密码校验。）
  

其中复位应答和防冲突机制这两部分在上面已经移植完了。后续会继续移植剩下两部分。
4.3、对数据块的利用

我们将继续完成如下利用函数：

• 读（Read）：读一个块；
  
• 写（Write）：写一个块；
  
• 加（Increment）：对数值块举行加值；
  
• 减（Decrement）：对数值块举行减值；
  
• 存储（Restore）：将块中的内容存到数据寄存器中；
  
• 传输（Transfer）：将数据寄存器中的内容写入块中；
  
• 中断（Halt）：将卡置于暂停工作状态；
  

5、美满剩余的利用函数

下面将直接给出完备的mfrc522.h和mfrc522.c。
5.1、mfrc522.h

1. #ifndef MFRC522_H
2. #define MFRC522_H
4. #include <gpiod.h>
5. #include "spi.h"
7. #define MI_OK                                        0
8. #define MI_NOTAGERR                                1
9. #define MI_ERR                                        2
11. #define MFRC522_MAX_LEN                 18
13. /* MFRC522 REG */
14. // Page 0 - Command and Status
15. #define        RFU00                                         0x00   
16. #define        CommandReg                                    0x01   
17. #define        ComIEnReg                                     0x02   
18. #define        DivlEnReg                                     0x03   
19. #define        ComIrqReg                                     0x04   
20. #define        DivIrqReg                                     0x05
21. #define        ErrorReg                                      0x06   
22. #define        Status1Reg                                    0x07   
23. #define        Status2Reg                                    0x08   
24. #define        FIFODataReg                                   0x09
25. #define        FIFOLevelReg                                  0x0A
26. #define        WaterLevelReg                                 0x0B
27. #define        ControlReg                                    0x0C
28. #define        BitFramingReg                                 0x0D
29. #define        CollReg                                       0x0E
30. #define        RFU0F                                         0x0F
31. // Page 1 - Command
32. #define        RFU10                                         0x10
33. #define        ModeReg                                       0x11
34. #define        TxModeReg                                     0x12
35. #define        RxModeReg                                     0x13
36. #define        TxControlReg                                  0x14
37. #define        TxAutoReg                                     0x15
38. #define        TxSelReg                                      0x16
39. #define        RxSelReg                                      0x17
40. #define        RxThresholdReg                                0x18
41. #define        DemodReg                                      0x19
42. #define        RFU1A                                         0x1A
43. #define        RFU1B                                         0x1B
44. #define        MifareReg                                     0x1C
45. #define        RFU1D                                         0x1D
46. #define        RFU1E                                         0x1E
47. #define        SerialSpeedReg                                0x1F
48. // Page 2 - CFG
49. #define        RFU20                                         0x20  
50. #define        CRCResultRegM                                 0x21
51. #define        CRCResultRegL                                 0x22
52. #define        RFU23                                         0x23
53. #define        ModWidthReg                                   0x24
54. #define        RFU25                                         0x25
55. #define        RFCfgReg                                      0x26
56. #define        GsNReg                                        0x27
57. #define        CWGsCfgReg                                    0x28
58. #define        ModGsCfgReg                                   0x29
59. #define        TModeReg                                      0x2A
60. #define        TPrescalerReg                                 0x2B
61. #define        TReloadRegH                                   0x2C
62. #define        TReloadRegL                                   0x2D
63. #define        TCounterValueRegH                             0x2E
64. #define        TCounterValueRegL                             0x2F
65. // Page 3 - TestRegister
66. #define        RFU30                                         0x30
67. #define        TestSel1Reg                                   0x31
68. #define        TestSel2Reg                                   0x32
69. #define        TestPinEnReg                                  0x33
70. #define        TestPinValueReg                               0x34
71. #define        TestBusReg                                    0x35
72. #define        AutoTestReg                                   0x36
73. #define        VersionReg                                    0x37
74. #define        AnalogTestReg                                 0x38
75. #define        TestDAC1Reg                                   0x39  
76. #define        TestDAC2Reg                                   0x3A   
77. #define        TestADCReg                                    0x3B   
78. #define        RFU3C                                         0x3C   
79. #define        RFU3D                                         0x3D   
80. #define        RFU3E                                         0x3E   
81. #define        RFU3F                                                            0x3F
83. /* MFRC522 CMD */
84. #define PCD_IDLE                        0x00               // 取消当前命令
85. #define PCD_AUTHENT                     0x0E               // 验证密钥
86. #define PCD_RECEIVE                     0x08               // 接收数据
87. #define PCD_TRANSMIT                    0x04               // 发送数据
88. #define PCD_TRANSCEIVE                  0x0C               // 发送并接收数据
89. #define PCD_RESETPHASE                  0x0F               // 复位
90. #define PCD_CALCCRC                     0x03               // CRC计算
92. /* IC-S50 CMD */
93. #define PICC_REQIDL                     0x26               // 寻天线区内未进入休眠状态
94. #define PICC_REQALL                     0x52               // 寻天线区内全部卡
95. #define PICC_ANTICOLL1                  0x93               // 防冲撞
96. #define PICC_ANTICOLL2                  0x95               // 防冲撞
97. #define PICC_AUTHENT1A                  0x60               // 验证A密钥
98. #define PICC_AUTHENT1B                  0x61               // 验证B密钥
99. #define PICC_READ                       0x30               // 读块
100. #define PICC_WRITE                      0xA0               // 写块
101. #define PICC_DECREMENT                  0xC0               // 扣款
102. #define PICC_INCREMENT                  0xC1               // 充值
103. #define PICC_RESTORE                    0xC2               // 调块数据到缓冲区
104. #define PICC_TRANSFER                   0xB0               // 保存缓冲区中数据
105. #define PICC_HALT                       0x50               // 休眠
107. void mfrc522_reset(void);
108. void mfrc522_config_iso_type(uint8_t type);
109. uint8_t mfrc522_request(uint8_t req_code, uint8_t *tag_type);
110. uint8_t mfrc522_anticoll(uint8_t *snr);
111. uint8_t mfrc522_select(uint8_t *snr);
112. uint8_t mfrc522_auth_state(uint8_t auth_mode, uint8_t addr, uint8_t *key, uint8_t *snr);
113. uint8_t mfrc522_read(uint8_t addr, uint8_t *data);
114. uint8_t mfrc522_write(uint8_t addr, uint8_t *data);
115. uint8_t mfrc522_write_string(uint8_t addr, uint8_t *data);
116. uint8_t mfrc522_read_string(uint8_t addr, uint8_t *data);
117. uint8_t mfrc522_halt(void);
118. uint8_t mfrc522_change_keya(uint8_t addr, uint8_t *keya);
119. uint8_t mfrc522_write_data_block(uint8_t addr, uint8_t *data, uint8_t len);
120. uint8_t mfrc522_read_data_block(uint8_t addr, uint8_t *data);
121. uint8_t mfrc522_write_amount(uint8_t addr, uint32_t data);
122. uint8_t mfrc522_read_amount(uint8_t addr, uint32_t *data);
123. int mfrc522_init(const char *spi_dev, const char *cs_chip, uint8_t cs_line, const char *rst_chip, uint8_t rst_line);
124. void mfrc522_exit(void);
126. #endif

复制代码

5.2、mfrc522.c

1. /* mfrc522.c */
3. #include "mfrc522.h"
5. static spi_handle_t *mfrc522_spi;
6. static struct gpiod_chip *rst_gpiochip;
7. static struct gpiod_line *rst_gpioline;
9. /**
10. * @brief 写入MFRC522寄存器
11. * @param reg 寄存器地址
12. * @param value 写入的值
13. */
14. static void mfrc522_write_reg(uint8_t reg, uint8_t value)
15. {
16.     uint8_t send_buf[2];
18.     send_buf[0] = (reg << 1) & 0x7E;
19.     send_buf[1] = value;
21.     spi_write_nbyte_data(mfrc522_spi, send_buf, sizeof(send_buf));
22. }
24. /**
25. * @brief 读取MFRC522寄存器
26. * @param reg 寄存器地址
27. * @return 读取的值
28. */
29. static uint8_t mfrc522_read_reg(uint8_t reg)
30. {
31.     uint8_t send_buf[2];
32.     uint8_t recv_buf[2] = {0};
34.     send_buf[0] = ((reg << 1) & 0x7E) | 0x80;
35.     send_buf[1] = 0x00;
37.     spi_write_and_read(mfrc522_spi, send_buf, sizeof(send_buf), recv_buf);
38.     return recv_buf[1];
39. }
41. /**
42. * @brief 将寄存器中指定的位置1
43. * @param reg 寄存器地址
44. * @param mask 要设置的位掩码
45. */
46. static void mfrc522_set_bit_mask(uint8_t reg, uint8_t mask)
47. {
48.     uint8_t temp;
50.     temp = mfrc522_read_reg(reg);
51.     mfrc522_write_reg(reg, temp | mask);
52. }
54. /**
55. * @brief 将寄存器中指定的位清0
56. * @param reg 寄存器地址
57. * @param mask 要清除的位掩码
58. */
59. static void mfrc522_clr_bit_mask(uint8_t reg, uint8_t mask)
60. {
61.     uint8_t temp;
63.     temp = mfrc522_read_reg(reg);
64.     mfrc522_write_reg(reg, temp & (~mask));
65. }
67. /**
68. * @brief 使能复位引脚
69. */
70. static void mfrc522_rst_enabled(void)
71. {
72.     gpiod_line_set_value(rst_gpioline, 0);
73. }
75. /**
76. * @brief 禁用复位引脚
77. */
78. static void mfrc522_rst_disabled(void)
79. {
80.     gpiod_line_set_value(rst_gpioline, 1);
81. }
83. /**
84. * @brief 复位MFRC522
85. */
86. void mfrc522_reset(void)
87. {
88.     mfrc522_rst_disabled();
89.     usleep(1);
91.     mfrc522_rst_enabled(); // 切断内部电流吸收，关闭振荡器，断开输入管脚与外部电路的连接
92.     usleep(1);
94.     mfrc522_rst_disabled(); // 上升沿启动内部复位阶段
95.     usleep(1);
97.     mfrc522_write_reg(CommandReg, PCD_RESETPHASE); // 软复位
99.     while (mfrc522_read_reg(CommandReg) & 0x10) // 等待MFRC522唤醒结束
100.         ;
101.     usleep(1);
103.     mfrc522_write_reg(ModeReg, 0x3D); // 定义发送和接收常用模式：和Mifare卡通讯，CRC初始值0x6363
105.     mfrc522_write_reg(TReloadRegL, 30); // 16位定时器低位
106.     mfrc522_write_reg(TReloadRegH, 0);  // 16位定时器高位
108.     mfrc522_write_reg(TModeReg, 0x8D); // 定义内部定时器的设置
110.     mfrc522_write_reg(TPrescalerReg, 0x3E); // 设置定时器分频系数
112.     mfrc522_write_reg(TxAutoReg, 0x40); // 调制发送信号为100%ASK
113. }
115. /**
116. * @brief 打开天线
117. */
118. static void mfrc522_antenna_on(void)
119. {
120.     uint8_t temp;
122.     temp = mfrc522_read_reg(TxControlReg);
123.     if (!(temp & 0x03))
124.         mfrc522_set_bit_mask(TxControlReg, 0x03);
125. }
127. /**
128. * @brief 关闭天线
129. */
130. static void mfrc522_antenna_off(void)
131. {
132.     mfrc522_clr_bit_mask(TxControlReg, 0x03);
133. }
135. /**
136. * @brief 配置ISO类型
137. * @param type ISO类型（'A' 或 'B'）
138. */
139. void mfrc522_config_iso_type(uint8_t type)
140. {
141.     if (type == 'A') // ISO14443_A
142.     {
143.         mfrc522_clr_bit_mask(Status2Reg, 0x08);
145.         mfrc522_write_reg(ModeReg, 0x3D);
147.         mfrc522_write_reg(RxSelReg, 0x86);
149.         mfrc522_write_reg(RFCfgReg, 0x7F);
151.         mfrc522_write_reg(TReloadRegL, 30);
153.         mfrc522_write_reg(TReloadRegH, 0);
155.         mfrc522_write_reg(TModeReg, 0x8D);
157.         mfrc522_write_reg(TPrescalerReg, 0x3E);
159.         usleep(2);
161.         mfrc522_antenna_on(); // 开天线
162.     }
163. }
165. /**
166. * @brief 通过MFRC522与ISO14443卡通信
167. * @param command 命令
168. * @param send_buf 发送缓冲区
169. * @param send_buf_len 发送缓冲区长度
170. * @param recv_buf 接收缓冲区
171. * @param recv_buf_len 接收缓冲区长度
172. * @return 状态码
173. */
174. static uint8_t mfrc522_to_card(uint8_t command, uint8_t *send_buf, uint8_t send_buf_len, uint8_t *recv_buf, uint32_t *recv_buf_len)
175. {
176.     uint8_t status = MI_ERR;
177.     uint8_t irq_en = 0x00;
178.     uint8_t wait_irq = 0x00;
179.     uint8_t last_bits;
180.     uint8_t n;
181.     uint32_t i = 0;
183.     switch (command)
184.     {
185.     case PCD_AUTHENT: // Mifare认证
186.     {
187.         irq_en = 0x12;   // 允许错误中断请求ErrIEn  允许空闲中断IdleIEn
188.         wait_irq = 0x10; // 认证寻卡等待时候 查询空闲中断标志位
189.         break;
190.     }
191.     case PCD_TRANSCEIVE: // 接收发送 发送接收
192.     {
193.         irq_en = 0x77;   // 允许TxIEn RxIEn IdleIEn LoAlertIEn ErrIEn TimerIEn
194.         wait_irq = 0x30; // 寻卡等待时候 查询接收中断标志位与 空闲中断标志位
195.         break;
196.     }
197.     default:
198.         break;
199.     }
201.     mfrc522_write_reg(ComIEnReg, irq_en | 0x80); // IRqInv置位管脚IRQ与Status1Reg的IRq位的值相反
202.     mfrc522_clr_bit_mask(ComIrqReg, 0x80);       // Set1该位清零时，CommIRqReg的屏蔽位清零
203.     mfrc522_write_reg(CommandReg, PCD_IDLE);     // 写空闲命令
205.     mfrc522_set_bit_mask(FIFOLevelReg, 0x80); // 置位FlushBuffer清除内部FIFO的读和写指针以及ErrReg的BufferOvfl标志位被清除
207.     for (i = 0; i < send_buf_len; i++)
208.         mfrc522_write_reg(FIFODataReg, send_buf[i]); // 写数据进FIFOdata
210.     mfrc522_write_reg(CommandReg, command); // 写命令
212.     if (command == PCD_TRANSCEIVE)
213.         mfrc522_set_bit_mask(BitFramingReg, 0x80); // StartSend置位启动数据发送 该位与收发命令使用时才有效
215.     do // 认证与寻卡等待时间
216.     {
217.         n = mfrc522_read_reg(ComIrqReg); // 查询事件中断
218.         usleep(1000);
219.         i++;
220.     } while ((i != 25) && !(n & 0x01) && !(n & wait_irq));
222.     mfrc522_clr_bit_mask(BitFramingReg, 0x80); // 清理允许StartSend位
224.     if (i != 25)
225.     {
226.         if (!(mfrc522_read_reg(ErrorReg) & 0x1B)) // 读错误标志寄存器BufferOfI CollErr ParityErr ProtocolErr
227.         {
228.             status = MI_OK;
230.             if (n & irq_en & 0x01) // 是否发生定时器中断
231.                 status = MI_NOTAGERR;
233.             if (command == PCD_TRANSCEIVE)
234.             {
235.                 n = mfrc522_read_reg(FIFOLevelReg);              // 读FIFO中保存的字节数
236.                 last_bits = mfrc522_read_reg(ControlReg) & 0x07; // 最后接收到得字节的有效位数
238.                 if (last_bits)
239.                     *recv_buf_len = (n - 1) * 8 + last_bits; // N个字节数减去1（最后一个字节）+最后一位的位数 读取到的数据总位数
240.                 else
241.                     *recv_buf_len = n * 8; // 最后接收到的字节整个字节有效
243.                 if (n == 0)
244.                     n = 1;
246.                 if (n > MFRC522_MAX_LEN)
247.                     n = MFRC522_MAX_LEN;
249.                 for (i = 0; i < n; i++)
250.                     recv_buf[i] = mfrc522_read_reg(FIFODataReg); // 从FIFOdata读数据
251.             }
252.         }
253.         else
254.             status = MI_ERR;
255.     }
257.     mfrc522_set_bit_mask(ControlReg, 0x80);
258.     mfrc522_write_reg(CommandReg, PCD_IDLE);
260.     return status;
261. }
263. /**
264. * @brief 防冲撞
265. * @param snr 卡片序列号
266. * @return 状态码
267. */
268. uint8_t mfrc522_anticoll(uint8_t *snr)
269. {
270.     uint8_t status;
271.     uint8_t i, snr_check = 0;
272.     uint8_t com_buf[MFRC522_MAX_LEN];
273.     uint32_t len;
275.     mfrc522_clr_bit_mask(Status2Reg, 0x08); // 清MFCryptol On位 只有成功执行MFAuthent命令后，该位才能置位
276.     mfrc522_write_reg(BitFramingReg, 0x00); // 清理寄存器 停止收发
277.     mfrc522_clr_bit_mask(CollReg, 0x80);    // 清ValuesAfterColl所有接收的位在冲突后被清除
279.     com_buf[0] = 0x93; // 卡片防冲突命令
280.     com_buf[1] = 0x20;
282.     status = mfrc522_to_card(PCD_TRANSCEIVE, com_buf, 2, com_buf, &len); // 与卡片通信
284.     if (status == MI_OK) // 通信成功
285.     {
286.         for (i = 0; i < 4; i++)
287.         {
288.             *(snr + i) = com_buf[i]; // 读出UID
289.             snr_check ^= com_buf[i];
290.         }
292.         if (snr_check != com_buf[i])
293.             status = MI_ERR;
294.     }
296.     mfrc522_set_bit_mask(CollReg, 0x80);
298.     return status;
299. }
301. /**
302. * @brief 寻卡
303. * @param req_code 寻卡命令
304. * @param tag_type 卡片类型
305. * @return 状态码
306. */
307. uint8_t mfrc522_request(uint8_t req_code, uint8_t *tag_type)
308. {
309.     uint8_t status;
310.     uint8_t com_buf[MFRC522_MAX_LEN];
311.     uint32_t len;
313.     mfrc522_clr_bit_mask(Status2Reg, 0x08);   // 清理指示MIFARECyptol单元接通以及所有卡的数据通信被加密的情况
314.     mfrc522_write_reg(BitFramingReg, 0x07);   // 发送的最后一个字节的 七位
315.     mfrc522_set_bit_mask(TxControlReg, 0x03); // TX1,TX2管脚的输出信号传递经发送调制的13.56的能量载波信号
317.     com_buf[0] = req_code; // 存入卡片命令字
319.     status = mfrc522_to_card(PCD_TRANSCEIVE, com_buf, 1, com_buf, &len); // 寻卡
321.     if ((status == MI_OK) && (len == 0x10)) // 寻卡成功返回卡类型
322.     {
323.         *tag_type = com_buf[0];
324.         *(tag_type + 1) = com_buf[1];
325.     }
326.     else
327.         status = MI_ERR;
329.     return status;
330. }
332. /**
333. * @brief CRC校验
334. * @param in_data 输入数据
335. * @param len 数据长度
336. * @param out_data 输出数据
337. */
338. static void mfrc522_calculate_crc(uint8_t *in_data, uint8_t len, uint8_t *out_data)
339. {
340.     uint8_t i, n;
342.     mfrc522_clr_bit_mask(DivIrqReg, 0x04); // CRCIrq = 0
343.     mfrc522_write_reg(CommandReg, PCD_IDLE);
344.     mfrc522_set_bit_mask(FIFOLevelReg, 0x80); // Clear the FIFO pointer
346.     // Writing data to the FIFO
347.     for (i = 0; i < len; i++)
348.         mfrc522_write_reg(FIFODataReg, *(in_data + i));
349.     mfrc522_write_reg(CommandReg, PCD_CALCCRC);
351.     // Wait CRC calculation is complete
352.     i = 0xFF;
353.     do
354.     {
355.         n = mfrc522_read_reg(DivIrqReg);
356.         i--;
357.     } while ((i != 0) && !(n & 0x04)); // CRCIrq = 1
359.     // Read CRC calculation result
360.     out_data[0] = mfrc522_read_reg(CRCResultRegL);
361.     out_data[1] = mfrc522_read_reg(CRCResultRegM);
362. }
364. /**
365. * @brief 选定卡片
366. * @param snr 卡片序列号
367. * @return 状态码
368. */
369. uint8_t mfrc522_select(uint8_t *snr)
370. {
371.     uint8_t status;
372.     uint8_t i;
373.     uint8_t com_buf[MFRC522_MAX_LEN];
374.     uint32_t len;
376.     com_buf[0] = PICC_ANTICOLL1;
377.     com_buf[1] = 0x70;
378.     com_buf[6] = 0;
380.     for (i = 0; i < 4; i++)
381.     {
382.         com_buf[i + 2] = *(snr + i);
383.         com_buf[6] ^= *(snr + i);
384.     }
386.     mfrc522_calculate_crc(com_buf, 7, &com_buf[7]);
388.     mfrc522_clr_bit_mask(Status2Reg, 0x08);
390.     status = mfrc522_to_card(PCD_TRANSCEIVE, com_buf, 9, com_buf, &len);
392.     if ((status == MI_OK) && (len == 0x18))
393.         status = MI_OK;
394.     else
395.         status = MI_ERR;
397.     return status;
398. }
400. /**
401. * @brief 验证卡片密码
402. * @param auth_mode 认证模式
403. * @param addr 块地址
404. * @param key 密钥
405. * @param snr 卡片序列号
406. * @return 状态码
407. */
408. uint8_t mfrc522_auth_state(uint8_t auth_mode, uint8_t addr, uint8_t *key, uint8_t *snr)
409. {
410.     uint8_t status;
411.     uint8_t i, com_buf[MFRC522_MAX_LEN];
412.     uint32_t len;
414.     com_buf[0] = auth_mode;
415.     com_buf[1] = addr;
417.     for (i = 0; i < 6; i++)
418.         com_buf[i + 2] = *(key + i);
420.     for (i = 0; i < 6; i++)
421.         com_buf[i + 8] = *(snr + i);
423.     status = mfrc522_to_card(PCD_AUTHENT, com_buf, 12, com_buf, &len);
425.     if ((status != MI_OK) || (!(mfrc522_read_reg(Status2Reg) & 0x08)))
426.         status = MI_ERR;
428.     return status;
429. }
431. /**
432. * @brief 写数据到M1卡一块
433. * @param addr 块地址
434. * @param data 写入的数据
435. * @return 状态码
436. */
437. uint8_t mfrc522_write(uint8_t addr, uint8_t *data)
438. {
439.     uint8_t status;
440.     uint8_t i, com_buf[MFRC522_MAX_LEN];
441.     uint32_t len;
443.     com_buf[0] = PICC_WRITE;
444.     com_buf[1] = addr;
446.     mfrc522_calculate_crc(com_buf, 2, &com_buf[2]);
448.     status = mfrc522_to_card(PCD_TRANSCEIVE, com_buf, 4, com_buf, &len);
450.     if ((status != MI_OK) || (len != 4) || ((com_buf[0] & 0x0F) != 0x0A))
451.         status = MI_ERR;
453.     if (status == MI_OK)
454.     {
455.         for (i = 0; i < 16; i++)
456.             com_buf[i] = *(data + i);
458.         mfrc522_calculate_crc(com_buf, 16, &com_buf[16]);
460.         status = mfrc522_to_card(PCD_TRANSCEIVE, com_buf, 18, com_buf, &len);
462.         if ((status != MI_OK) || (len != 4) || ((com_buf[0] & 0x0F) != 0x0A))
463.             status = MI_ERR;
464.     }
466.     return status;
467. }
469. /**
470. * @brief 读取M1卡一块数据
471. * @param addr 块地址
472. * @param data 读出的数据
473. * @return 状态码
474. */
475. uint8_t mfrc522_read(uint8_t addr, uint8_t *data)
476. {
477.     uint8_t status;
478.     uint8_t i, com_buf[MFRC522_MAX_LEN];
479.     uint32_t len;
481.     com_buf[0] = PICC_READ;
482.     com_buf[1] = addr;
484.     mfrc522_calculate_crc(com_buf, 2, &com_buf[2]);
486.     status = mfrc522_to_card(PCD_TRANSCEIVE, com_buf, 4, com_buf, &len);
488.     if ((status == MI_OK) && (len == 0x90))
489.     {
490.         for (i = 0; i < 16; i++)
491.             *(data + i) = com_buf[i];
492.     }
493.     else
494.         status = MI_ERR;
496.     return status;
497. }
499. /**
500. * @brief 判断 addr 是否数据块
501. * @param addr 块地址
502. * @return 返回值 1:是数据块；0:不是数据块
503. */
504. static uint8_t mfrc522_is_data_block(uint8_t addr)
505. {
506.     if (addr == 0)
507.     {
508.         printf("第0扇区的块0不可更改,不应对其进行操作\r\n");
509.         return 0;
510.     }
512.     /* 如果是数据块(不包含数据块0) */
513.     if ((addr < 64) && (((addr + 1) % 4) != 0))
514.     {
515.         return 1;
516.     }
518.     printf("块地址不是指向数据块\r\n");
519.     return 0;
520. }
522. /**
523. * @brief 写 data 字符串到M1卡中的数据块
524. * @param addr 数据块地址
525. * @param data 写入的数据
526. * @return 状态码
527. */
528. uint8_t mfrc522_write_string(uint8_t addr, uint8_t *data)
529. {
530.     /* 如果是数据块(不包含数据块0)，则写入 */
531.     if (mfrc522_is_data_block(addr))
532.     {
533.         return mfrc522_write(addr, data);
534.     }
536.     return MI_ERR;
537. }
539. /**
540. * @brief 读取M1卡中的一块数据到 data
541. * @param addr 数据块地址
542. * @param data 读出的数据
543. * @return 状态码
544. */
545. uint8_t mfrc522_read_string(uint8_t addr, uint8_t *data)
546. {
547.     /* 如果是数据块(不包含数据块0)，则读取 */
548.     if (mfrc522_is_data_block(addr))
549.     {
550.         return mfrc522_read(addr, data);
551.     }
553.     return MI_ERR;
554. }
556. /**
557. * @brief 命令卡片进入休眠状态
558. * @return 状态码
559. */
560. uint8_t mfrc522_halt(void)
561. {
562.     uint8_t com_buf[MFRC522_MAX_LEN];
563.     uint32_t len;
565.     com_buf[0] = PICC_HALT;
566.     com_buf[1] = 0;
568.     mfrc522_calculate_crc(com_buf, 2, &com_buf[2]);
569.     mfrc522_to_card(PCD_TRANSCEIVE, com_buf, 4, com_buf, &len);
571.     return MI_OK;
572. }
574. /**
575. * @brief 写入钱包金额
576. * @param addr 块地址
577. * @param data 写入的金额
578. * @return 状态码
579. */
580. uint8_t mfrc522_write_amount(uint8_t addr, uint32_t data)
581. {
582.     uint8_t status;
583.     uint8_t com_buf[16];
584.     com_buf[0] = (data & ((uint32_t)0x000000ff));
585.     com_buf[1] = (data & ((uint32_t)0x0000ff00)) >> 8;
586.     com_buf[2] = (data & ((uint32_t)0x00ff0000)) >> 16;
587.     com_buf[3] = (data & ((uint32_t)0xff000000)) >> 24;
589.     com_buf[4] = ~(data & ((uint32_t)0x000000ff));
590.     com_buf[5] = ~(data & ((uint32_t)0x0000ff00)) >> 8;
591.     com_buf[6] = ~(data & ((uint32_t)0x00ff0000)) >> 16;
592.     com_buf[7] = ~(data & ((uint32_t)0xff000000)) >> 24;
594.     com_buf[8] = (data & ((uint32_t)0x000000ff));
595.     com_buf[9] = (data & ((uint32_t)0x0000ff00)) >> 8;
596.     com_buf[10] = (data & ((uint32_t)0x00ff0000)) >> 16;
597.     com_buf[11] = (data & ((uint32_t)0xff000000)) >> 24;
599.     com_buf[12] = addr;
600.     com_buf[13] = ~addr;
601.     com_buf[14] = addr;
602.     com_buf[15] = ~addr;
603.     status = mfrc522_write(addr, com_buf);
604.     return status;
605. }
607. /**
608. * @brief 读取钱包金额
609. * @param addr 块地址
610. * @param data 读出的金额
611. * @return 状态码
612. */
613. uint8_t mfrc522_read_amount(uint8_t addr, uint32_t *data)
614. {
615.     uint8_t status = MI_ERR;
616.     uint8_t j;
617.     uint8_t com_buf[16];
619.     status = mfrc522_read(addr, com_buf);
620.     if (status != MI_OK)
621.         return status;
623.     for (j = 0; j < 4; j++)
624.     {
625.         if ((com_buf[j] != com_buf[j + 8]) && (com_buf[j] != ~com_buf[j + 4])) // 验证一下是不是钱包的数据
626.             break;
627.     }
629.     if (j == 4)
630.     {
631.         status = MI_OK;
632.         *data = com_buf[0] + (com_buf[1] << 8) + (com_buf[2] << 16) + (com_buf[3] << 24);
633.     }
634.     else
635.     {
636.         status = MI_ERR;
637.         *data = 0;
638.     }
640.     return status;
641. }
643. /**
644. * @brief 修改控制块 addr 的密码A。注意 addr 指的是控制块的地址。
645. *        必须要校验密码B，密码B默认为6个0xFF，如果密码B也忘记了，那就改不了密码A了
646. * @note  注意：该函数仅适用于默认的存储控制模式，若是其他的话可能出现问题
647. * @param addr 控制块地址
648. * @param keya 新的密码A，六个字符，比如 "123456"
649. * @return 状态码
650. */
651. uint8_t mfrc522_change_keya(uint8_t addr, uint8_t *keya)
652. {
653.     uint8_t keyb_value[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; // B密钥
654.     uint8_t array_id[4];                                         /*先后存放IC卡的类型和UID(IC卡序列号)*/
655.     uint8_t com_buf[16];
656.     uint8_t j;
658.     /*寻卡*/
659.     while (mfrc522_request(PICC_REQALL, array_id) != MI_OK)
660.     {
661.         printf("寻卡失败\r\n");
662.         usleep(1000000);
663.     }
665.     printf("寻卡成功\n");
667.     /* 防冲突（当有多张卡进入读写器操作范围时，防冲突机制会从其中选择一张进行操作）*/
668.     if (mfrc522_anticoll(array_id) == MI_OK)
669.     {
670.         /* 选中卡 */
671.         mfrc522_select(array_id);
673.         /* 校验 B 密码 */
674.         if (mfrc522_auth_state(PICC_AUTHENT1B, addr, keyb_value, array_id) != MI_OK)
675.         {
676.             printf("检验密码B失败\r\n");
677.         }
679.         // 读取控制块里原本的数据（只要修改密码A，其他数据不改）
680.         if (mfrc522_read(addr, com_buf) != MI_OK)
681.         {
682.             printf("读取控制块数据失败\r\n");
683.             return MI_ERR;
684.         }
686.         /* 修改密码A */
687.         for (j = 0; j < 6; j++)
688.             com_buf[j] = keya[j];
690.         if (mfrc522_write(addr, com_buf) != MI_OK)
691.         {
692.             printf("写入数据到控制块失败\r\n");
693.             return MI_ERR;
694.         }
696.         printf("密码A修改成功！\r\n");
697.         mfrc522_halt();
699.         return MI_OK;
700.     }
702.     return MI_ERR;
703. }
704. /**
705. * @brief 按照RC522操作流程写入16字节数据到块 addr
706. *        函数里校验的是密码B，密码B默认为6个0xFF，也可以校验密码A
707. *        mfrc522_write_data_block(1, "123456789\n", 10); //字符串不够16个字节的后面补零写入
708. * @note  注意：该函数仅适用于默认的存储控制模式，若是其他的话可能出现问题
709. *        注意：使用该函数要注意 addr 是块0、数据块还是控制块，该函数内部不对此做判断
710. * @param addr 块地址
711. * @param data 写入的数据
712. * @param len 数据长度
713. * @return 状态码
714. */
715. uint8_t mfrc522_write_data_block(uint8_t addr, uint8_t *data, uint8_t len)
716. {
717.     uint8_t keyb_value[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; // B密钥
718.     uint8_t array_id[4];                                         /*先后存放IC卡的类型和UID(IC卡序列号)*/
719.     uint8_t com_buf[16];
720.     uint8_t j;
722.     /*寻卡*/
723.     while (mfrc522_request(PICC_REQALL, array_id) != MI_OK)
724.     {
725.         printf("寻卡失败\r\n");
726.         usleep(1000000);
727.     }
729.     printf("寻卡成功\n");
731.     /* 防冲突（当有多张卡进入读写器操作范围时，防冲突机制会从其中选择一张进行操作）*/
732.     if (mfrc522_anticoll(array_id) == MI_OK)
733.     {
734.         /* 选中卡 */
735.         mfrc522_select(array_id);
737.         /* 校验 B 密码 */
738.         if (mfrc522_auth_state(PICC_AUTHENT1B, addr, keyb_value, array_id) != MI_OK)
739.         {
740.             printf("检验密码B失败\r\n");
741.         }
743.         /* 拷贝 data 里的 len 个字符到 com_buf */
744.         for (j = 0; j < 16; j++)
745.         {
746.             if (j < len)
747.                 com_buf[j] = data[j];
748.             else
749.                 com_buf[j] = 0; // 16个字节若是未填满的字节置0
750.         }
752.         /* 写入字符串 */
753.         if (mfrc522_write(addr, com_buf) != MI_OK)
754.         {
755.             printf("写入数据到数据块失败\r\n");
756.             return MI_ERR;
757.         }
759.         printf("写入数据成功！\r\n");
760.         mfrc522_halt();
762.         return MI_OK;
763.     }
765.     return MI_ERR;
766. }
768. /**
769. * @brief 读取M1卡数据
770. * @note  注意：该函数仅适用于默认的存储控制模式，若是其他的话可能出现问题
771. *        注意：使用该函数要注意 addr 是块0、数据块还是控制块，该函数内部不对此做判断
772. * @param addr 块地址
773. * @param data 读出的数据
774. * @return 状态码
775. */
776. uint8_t mfrc522_read_data_block(uint8_t addr, uint8_t *data)
777. {
778.     uint8_t keyb_value[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; // B密钥
779.     uint8_t array_id[4];                                         /*先后存放IC卡的类型和UID(IC卡序列号)*/
781.     /*寻卡*/
782.     while (mfrc522_request(PICC_REQALL, array_id) != MI_OK)
783.     {
784.         printf("寻卡失败\r\n");
785.         usleep(1000000);
786.     }
788.     printf("寻卡成功\n");
790.     /* 防冲突（当有多张卡进入读写器操作范围时，防冲突机制会从其中选择一张进行操作）*/
791.     if (mfrc522_anticoll(array_id) == MI_OK)
792.     {
793.         /* 选中卡 */
794.         mfrc522_select(array_id);
796.         /* 校验 B 密码 */
797.         if (mfrc522_auth_state(PICC_AUTHENT1B, addr, keyb_value, array_id) != MI_OK)
798.         {
799.             printf("检验密码B失败\r\n");
800.         }
802.         // 读取数据块里的数据到 data
803.         if (mfrc522_read(addr, data) != MI_OK)
804.         {
805.             printf("读取数据块失败\r\n");
806.             return MI_ERR;
807.         }
809.         printf("读取数据成功！\r\n");
810.         mfrc522_halt();
812.         return MI_OK;
813.     }
815.     return MI_ERR;
816. }
818. /**
819. * @brief 初始化MFRC522
820. * @param spi_dev SPI设备文件路径
821. * @param cs_chip CS芯片名称
822. * @param cs_line CS引脚编号
823. * @param rst_chip 复位芯片名称
824. * @param rst_line 复位引脚编号
825. * @return 初始化结果
826. */
827. int mfrc522_init(const char *spi_dev,
828.                  const char *cs_chip, uint8_t cs_line,
829.                  const char *rst_chip, uint8_t rst_line)
830. {
831.     int ret;
833.     if (!spi_dev)
834.         return -1;
836.     if (!cs_chip || !rst_chip)
837.         return -1;
839.     /* SPI初始化 */
840.     mfrc522_spi = spi_handle_alloc(spi_dev, SPIMODE0, S_1M, cs_chip, cs_line);
841.     if (!mfrc522_spi)
842.         return -1;
844.     /* 复位脚初始化 */
845.     rst_gpiochip = gpiod_chip_open(rst_chip);
846.     if (rst_gpiochip == NULL)
847.     {
848.         printf("gpiod_chip_open failed!\n");
849.         return -1;
850.     }
851.     rst_gpioline = gpiod_chip_get_line(rst_gpiochip, rst_line);
852.     if (rst_gpioline == NULL)
853.     {
854.         printf("gpiod_chip_get_line failed!\n");
855.         return -1;
856.     }
857.     ret = gpiod_line_request_output(rst_gpioline, "rst_gpioline", 1);
858.     if (ret < 0)
859.     {
860.         printf("gpiod_line_request_output failed!\n");
861.         return -1;
862.     }
864.     mfrc522_rst_disabled();
866.     return 0;
867. }
869. /**
870. * @brief 反初始化MFRC522
871. */
872. void mfrc522_exit(void)
873. {
874.     if (mfrc522_spi)
875.         spi_handle_free(mfrc522_spi);
877.     if (rst_gpioline)
878.         gpiod_line_release(rst_gpioline);
879.     if (rst_gpiochip)
880.         gpiod_chip_close(rst_gpiochip);
881. }

复制代码

6、测试

下面编写一个测试步伐main.c。完成写入金额和读取金额的利用。

1. /* main.c */
3. #include <stdio.h>
4. #include <unistd.h>
5. #include <fcntl.h>
6. #include <stdlib.h>
7. #include <pthread.h>
8. #include <gpiod.h>
9. #include <math.h>
11. #include "mfrc522.h"
13. // 通常新卡的密码A和密码B都是0xff。可以通过访问每个扇区的尾块来修改密码。
14. // 修改完密码后，要自行记录。因为密码A和密码B都是不可读的。
15. uint8_t key_value[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; // 卡A密钥
17. int main()
18. {
19.     unsigned char id[4];
20.     unsigned char status;
21.     int ret;
22.     uint32_t write_value = 100;
23.     uint32_t read_value;
24.        
25.         /*
26.     * 块地址的计算：
27.     * 块地址   是从0开始的连续编号，范围是 0x00 到 0x3F（总共64个块）
28.     * 扇区地址 是从0开始的连续编号，范围是 0x00 到 0x0F（总共16个扇区）
29.     *
30.     * 具体计算公式：
31.     * 扇区号 = 块地址 / 4
32.     * 块号 = 块地址 % 4
33.     *
34.     * 假设块地址为0x11
35.     * 扇区号 = 0x11 / 4 = 0x04（第5个扇区）
36.     * 块号 = 0x11 % 4 = 0x01（第2个块，即块1）
37.     * 因此，0x11 对应 扇区4的块1。
38.     */
39.     unsigned char addr = 0x11;
40.    
41.     ret = mfrc522_init("/dev/spidev3.0",
42.                        "/dev/gpiochip6", 11,
43.                        "/dev/gpiochip6", 10);
44.     if (ret != 0)
45.     {
46.         printf("mfrc522_init fialed!\n");
47.         return -1;
48.     }
50.     mfrc522_reset();
52.     mfrc522_config_iso_type('A');
54.     while (1)
55.     {
56.         status = mfrc522_request(PICC_REQALL, id);
57.         if (status != MI_OK)
58.             printf("request card fialed!\n");
60.         if (status == MI_OK)
61.         {
62.             printf("request card successfully!\n");
63.             if (mfrc522_anticoll(id) != MI_OK)
64.             {
65.                 printf("anticoll failed, continue!\n");
66.                 continue;
67.             }
69.             status = mfrc522_select(id); // 选定卡片
70.             if (status != MI_OK)
71.             {
72.                 printf("select card failed, continue!\n");
73.                 continue;
74.             }
76.             status = mfrc522_auth_state(PICC_AUTHENT1A, addr, key_value, id); // 校验密码
77.             if (status != MI_OK)
78.             {
79.                 printf("autu failed, continue!\n");
80.                 continue;
81.             }
83.             status =  mfrc522_write_amount(addr, write_value); // 写入金额
84.             if (status != MI_OK)
85.             {
86.                 printf("write amount failed, continue!\n");
87.                 continue;
88.             }
89.             
90.             status =  mfrc522_read_amount(addr, &read_value);
91.             if (status != MI_OK)
92.             {
93.                 printf("read amount failed, continue!\n");
94.                 continue;
95.             }
97.             printf("card uid = %02X%02X%02X%02X\n", id[0], id[1], id[2], id[3]);
98.                         printf("read value = %d\r\n", read_value);
99.                        
100.             mfrc522_halt();
101.             
102.             break;
103.         }
105.         sleep(0.1);
106.     }
108.     mfrc522_exit();
110.     return 0;
111. }

复制代码

目前总共涉及的文件有：

执行如下命令编译步伐：

1. gcc -o build main.c mfrc522.c spi.c -lgpiod

复制代码

执行如下命令运行步伐：

1. sudo ./build

复制代码

利用手机nfc工具检察，扇区4的块1被修改。0x64转成十进制就是100。

7、总结

参考文章：基于STM32的RC522门禁系统步伐解读_mfrc522-CSDN博客
依稀记得小时间拿家里的门禁卡去外貌找人复制一个新的，那已是10几年前的事。在查阅MFRC522手册时，发现这款芯片诞生于2007年。其实用的产物功能我们不谈。只是如今2025年，在嵌入式教育的视野中另有它的存在。固然另有很多外设都经典传播至今。那对于嵌入式入门学习来说，到底什么是核心？我想更多是培养学者独立阅读数据手册的技能，熟悉常见的外设通讯协议，加强步伐编码或阅读能力等等。但初学时的这种习惯容易遗留到以后的工作中，一字一句的扣代码只会降低开发效率，也不会让你大富大贵。我只想表达，不必花太多心思在雷同于这种寄存器或外设驱动的研究上，更应该侧重于上层应用或框架性的东西。包括Linux驱动的学习，重点在理解装备驱动框架，各种子系统框架。
以上也只是我入行一年左右带给我的眼界而作出的讨论。不必理会。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。