目的
了解MFRC522读写卡芯片和S50非接触IC卡的驱动原理，通过配置 STM32F030 的GPIO和外设SPI，完成MFRC522传感器与卡的数据读写以及扣款充值实验。
原理
MFRC522是高度集成的非接触式（13.56MHz）读写卡芯片。此芯片利用调制和解调的原理，并将它们完全集成到各种非接触式通信方法和协议中。MFRC522的内部发送器部分可驱动读写器天线与ISO14443A/MIFARE卡和应答机的通信，无需其它的电路。接收器部分提供一个功能强大和高效的解调和译码电路，用来处理兼容ISO14443A/MIFARE卡和应答机的信号。
RC522支持SPI、I2C和UART接口，本实验使用的是SPI接口。RC522只能工作于从模式，最高传输速率为10 Mbps，数据与时钟相位关系满足“空闲态时钟为低电平，在时钟上升沿同步接收和发送数据，在下降沿数据转换”的约束关系。
简化MRFC522框图：
模拟接口用来处理模拟信号的调制和解调。非接触式UART用来处理与主机通信时的协议要求。FIFO缓冲区快速而方便地实现了主机和非接触式UART之间数据传输。
IC卡特点：
- 容量为8K位EEPROM
- 分为16个扇区，每个扇区为4块，每块16个字节,以块为存取单位
- 每个扇区有独立的一组密码及访问控制
- 每张卡有唯一序列号，为32位
- 具有防冲突机制，支持多卡操作
- 无电源，自带天线，内含加密控制逻辑和通讯逻辑电路
- 数据保存期为10年，可改写10万次，读无限次
- 工作温度：-20℃~50℃(湿度为90%)
- 工作频率：13.56MHZ
- 通信速率：106 KBPS
- 读写距离：10 cm以内（与读写器有关）
卡片的电气部分只由一个天线和ASIC组成。
天线：卡片的天线是只有几组绕线的线圈，很适于封装到IS0卡片中。
ASIC：卡片的ASIC由一个高速（106KB波特率）的RF接口，一个控制单元和一个
8K位EEPROM组成。
工作原理：读写器向M1卡发一组固定频率的电磁波，卡片内有一个LC串联谐振电路，其频率与读写器发射的频率相同，在电磁波的激励下，LC谐振电路产生共振，从而使电容内有了电荷，在这个电容的另一端，接有一个单向导通的电子泵，将电容内的电荷送到另一个电容内储存，当所积累的电荷达到2V时，此电容可做为电源为其它电路提供工作电压，将卡内数据发射出去或接取读写器的数据。
M1射频卡与MFRC522的通讯:
- 复位应答：
M1射频卡的通讯协议和通讯波特率是定义好的，当有卡片进入读写器的操作范围时，读写器以特定的协议与它通讯，从而确定该卡是否为M1射频卡，即验证卡片的卡型。
- 防冲突机制：
当有多张卡进入读写器操作范围时，防冲突机制会从其中选择一张进行操作，未选中的则处于空闲模式等待下一次选卡，该过程会返回被选卡的序列号。
- 选择卡片：
选择被选中的卡的序列号，并同时返回卡的容量代码。
- 三次互相确认：
选定要处理的卡片之后，读写器就确定要访问的扇区号，并对该扇区密码进行密码校验，在三次相互认证之后就可以通过加密流进行通讯。（在选择另一扇区时，则必须进行另一扇区密码校验。）
- 读数据块的操作：
- 读(Read)：读一个块；
- 写(Write）：写一个块；
- 加（Increment）：对数值块进行加值；
- 减（Decrement）：对数值块进行减值；
- 存储（Restore）：将块中的内容存到数据寄存器中；
- 传输（Transfer）：将数据寄存器中的内容写入块中；
- 中止（Halt）：将卡置于暂停工作状态；
在IC卡集成电路中使用了两种类型的数据块：
- 读写块
用来读写16字节数据。
- 数据块
用于电子钱包功能（读取、递增、递减、传输、还原）。值最大占4个字节，为了提供错误检测和纠正功能，每个值都在一个值块中存储3次，剩下4个字节为任意地址字节（8位地址存储4次）。
步骤
在新建工程中新建两个文件分别命名为sensor_rfid.c和sensor_rfid.h，并将sensor_rfid.c文件保存在该工程文件夹中，并添加文件路径
在sensor_rfid.c文件中添加sensor_rfid.h头文件，定义SPI读取数据使用的字节以及卡初始化等待的最大次数
#include "sensor_rfid.h"
#define DUMMY_BYTE ((uint8_t)0x00)
#define CARD_INIT_RETRY_COUNT 10
在sensor_rfid.c文件中定义RC522_ReadData()函数，函数通过SPI时序实现读取RC522寄存器数据操作
// 读RC522寄存器
uint8_t RC522_ReadData(uint8_t address)
{
uint8_t data = 0;
SPI2_CS_ENABLE;
SPI2_ReadWriteByte(((address << 1) | 0x80) & 0xfe);
data = SPI2_ReadWriteByte(DUMMY_BYTE);
SPI2_CS_DISABLE;
return data;
}
在sensor_rfid.c文件中定义RC522_WriteData()函数，函数通过SPI时序实现写RC522寄存器操作
// 写RC522寄存器
void RC522_WriteData(uint8_t address, uint8_t data)
{
SPI2_CS_ENABLE;
SPI2_ReadWriteByte((address << 1) & 0x7e);
SPI2_ReadWriteByte(data);
SPI2_CS_DISABLE;
}
在sensor_rfid.c文件中添加RC522_SetReg()函数，将RC522某寄存器进行置位
// 置RC522寄存器位
void RC522_SetReg(uint8_t reg, uint8_t data)
{
uint8_t reg_data = RC522_ReadData(reg);
RC522_WriteData(reg, reg_data|data);
}
在sensor_rfid.c文件中添加RC522_ClearReg()函数，将RC522某寄存器进行复位
// 清RC522寄存器位
void RC522_ClearReg(uint8_t reg, uint8_t data)
{
uint8_t reg_data = RC522_ReadData(reg);
RC522_WriteData(reg, reg_data & ~data);
}
在sensor_rfid.c文件中定义RC522_Reset()函数，实现对芯片进行复位。函数通过向RC522中寄存器写相应数据实现对RC522芯片的复位操作
// 对RCC522芯片进行复位
void RC522_Reset(void)
{
RC522_WriteData(CommandReg, PCD_RESETPHASE);
RC522_WriteData(ModeReg, 0x3D);
RC522_WriteData(TReloadRegL, 30);
RC522_WriteData(TReloadRegH, 0);
RC522_WriteData(TModeReg, 0x8D);
RC522_WriteData(TPrescalerReg, 0x3E);
RC522_WriteData(TxASKReg, 0x40);
}
在sensor_rfid.c文件中添加RC522_AntennaOn()函数，打开RC522天线
// 打开天线
void RC522_AntennaOn(void)
{
if(!(RC522_ReadData(TxControlReg) & 0x03))
{
RC522_SetReg(TxControlReg, 0x03);
}
}
在sensor_rfid.c文件中添加RC522_AntennaOff()函数，关闭RC522天线
// 关闭天线
void RC522_AntennaOff(void)
{
RC522_ClearReg(TxControlReg, 0x03);
}
在sensor_rfid.c文件中添加M1Card_Config()函数，实现ISO14443A型卡初始化
// 针对M1卡进行初始化
void M1Card_Config(void)
{
RC522_ClearReg(Status2Reg, 0x08);
RC522_WriteData(ModeReg, 0x3D);
RC522_WriteData(RxSelReg, 0x86);
RC522_WriteData(RFCfgReg, 0x7F);
RC522_WriteData(TReloadRegL, 30);
RC522_WriteData(TReloadRegH, 0);
RC522_WriteData(TModeReg, 0x8D);
RC522_WriteData(TPrescalerReg, 0x3E);
RC522_AntennaOn();
}
在sensor_rfid.c文件中添加RC522_Init()函数，函数中实现了RC522复位、关闭天线、打开天线和ISO14443A型卡初始化
// 初始化RC522
void RC522_Init(void)
{
RC522_Reset(); // 对RC522芯片进行复位
RC522_AntennaOff(); // 关闭天线
RC522_AntennaOn(); // 打开天线
M1Card_Config(); // 针对M1卡进行初始化
}
在sensor_rfid.c文件中添加RC522_CardCom()函数，实现RC522和IC卡通讯，函数如下
// 通过RC522和ISO14443卡通讯
int8_t RC522_CardCom(uint8_t Command, uint8_t *InData, uint8_t InLength, uint8_t *OutData, uint32_t *OutLength)
{
uint8_t waitFor = 0x00;
switch(Command)
{
case PCD_AUTHENT: // 验证密钥
waitFor = 0x10; // 认证寻卡等待时间 查询空闲中断标志位
break;
case PCD_TRANSCEIVE: // 接收发送 发送接收
waitFor = 0x30;
break;
default:
break;
}
RC522_ClearReg(ComIrqReg, 0x80); // 清楚中断标志
RC522_WriteData(CommandReg, PCD_IDLE); // 关闭接收机的模拟部分，进入软关机模式，进入IDLE模式
RC522_SetReg(FIFOLevelReg, 0x80); // 清楚Fifo缓冲区及状态位
// 写数据进FIFOdata
for(uint32_t i=0; i<InLength; i++)
{
RC522_WriteData(FIFODataReg, InData[i]);
}
// 写入命令（PCD_TRANSCEIVE：开始传输并且传输完成后自动接收数据 PCD_AUTHENT：作为读取器执行MIFARE®标准身份验证）
RC522_WriteData(CommandReg, Command);
if(Command == PCD_TRANSCEIVE)
{
// 开始传输数据
RC522_SetReg(BitFramingReg, 0x80);
}
// 读取中断状态。PCD_TRANSCEIVE：等待接收完成或空闲模式 PCD_AUTHENT：等待系统进入空闲模式。
uint8_t state;
uint16_t i;
for(i=1200; i>0; i--)
{
state = RC522_ReadData(ComIrqReg);
if(state&waitFor || state&0x01)
{
break;
}
}
// 停止传输数据
RC522_ClearReg(BitFramingReg, 0x80);
int8_t status = MI_ERR;
if(i!=0) // 如果进入空闲模式
{
if(!(RC522_ReadData(ErrorReg)&0x1B)) // 判断是否存在错误。FIFO溢出、位冲突、奇偶校验错误、协议错误
{
status = MI_OK;
if(Command == PCD_TRANSCEIVE)
{
// 计算输出数据长度（位）
uint8_t number = RC522_ReadData(FIFOLevelReg); // 读FIFO中保存的字节数
uint8_t rxLastBits = RC522_ReadData(ControlReg) & 0x07; // 最后接收到的字节的有效位数
if(rxLastBits)
{
*OutLength = (number-1) * 8 + rxLastBits; // 读取到的数据总位数
}
else
{
*OutLength = number * 8; // 最后接收到的字节整个字节有效
}
// 计算输出数据长度（位）
if(number == 0)
{
number = 1;
}
if(number > MAXRLEN)
{
number = MAXRLEN;
}
for(i=0; i<number; i++)
{
OutData[i] = RC522_ReadData(FIFODataReg);
}
}
}
else
{
status = MI_ERR;
}
}
RC522_SetReg(ControlReg, 0x80);
RC522_WriteData(CommandReg, PCD_IDLE);
return status;
}
在sensor_rfid.c文件中添加Card_Find()函数，实现寻卡操作。函数将我们的寻卡命令PICC_REQIDL装填入要发送的数组，通过PcdComMF522()函数发送出去，如果此时在PCD有效范围内没有寻找到卡，则函数返回MI_ERR，若函数返回MI_OK，并且OutLen为0x10（16bit）为两个字节则说明寻卡成功，返回的两字节被装填入CardRevBuf数组
int8_t Card_Find(uint8_t Findway, uint8_t *Cardtype)
{
RC522_ClearReg(Status2Reg, 0x08); // 该位表示MIFARE®Crypto1单元已打开，因此与该卡的所有数据通信都已加密
RC522_WriteData(BitFramingReg, 0x07); // 不启动数据发送
RC522_SetReg(TxControlReg, 0x03);// TX1、TX2输出信号将传递经发送数据调制的13.56MHz的能量载波信号。
uint32_t OutLen;
uint8_t RC522_DataBuffer[MAXRLEN] = {Findway}; // 将寻卡命令填入到数组
int8_t status = RC522_CardCom(PCD_TRANSCEIVE, RC522_DataBuffer, 1, RC522_DataBuffer, &OutLen); // 发送命令并获取返回数据
if((status == MI_OK) && (OutLen == 0x10)) // 状态正确，并且返回16位数据
{
Cardtype[0] = RC522_DataBuffer[0]; // 获取卡类型
Cardtype[1] = RC522_DataBuffer[1];
}
else
{
status = MI_ERR;
}
return status;
}
在sensor_rfid.c文件中添加Card_Anticoll()函数，这个函数用于防冲突操作。防冲突操作就是将防冲突命令通过PcdComMF522()函数与PICC卡进行交互。防冲突命令是两个字节，其中第一字节为Mifare_One卡的防冲突命令字PICC_ANTICOLL1 （0x93），第二个字节为0x20。对于多个卡片同时进入有效区域的防冲突操作：由于是非接触式的，同一时间天线作用范围内可能不只一张卡时，即有多于一张的IC卡发回了卡序列号应答，则发生了冲突。函数如下
// 防冲撞
int8_t Card_Anticoll(uint8_t *card_sn)
{
// 该位表示MIFARE®Crypto1单元已打开，因此与该卡的所有数据通信都已加密
RC522_ClearReg(Status2Reg, 0x08);
// 不启动数据发送，接收的LSB位存放在位0，接收到的第二位放在位1，定义发送的最后一个字节的位数为8
RC522_WriteData(BitFramingReg, 0x00);
// 所有接收的位在冲突后将被清除。106kbit/s 有效。其他速率应该置1
RC522_ClearReg(CollReg, 0x80);
uint32_t OutLen;
uint8_t RC522_DataBuffer[MAXRLEN] = {0};
RC522_DataBuffer[0] = PICC_ANTICOLL1; // 0x93表明串联级别1
RC522_DataBuffer[1] = 0x20; // 表明PCD发送字节数为整两个字节
int8_t status = RC522_CardCom(PCD_TRANSCEIVE, RC522_DataBuffer, 2, RC522_DataBuffer, &OutLen);
if(status == MI_OK)
{
uint8_t sn_check = 0;
for(uint8_t i=0; i<4; i++)
{
card_sn[i] = RC522_DataBuffer[i];
sn_check ^= RC522_DataBuffer[i];
}
if(sn_check != RC522_DataBuffer[4]) // 返回四个字节，最后一个字节为校验位
{
status = MI_ERR;
}
}
RC522_SetReg(CollReg, 0x80); // 关闭冲撞检测
return status;
}
在sensor_rfid.c文件中添加CalulateCRC()函数，实现用MF522计算CRC16
// 用MF522计算CRC16函数
void CalulateCRC(uint8_t *Indata, uint8_t len, uint8_t *OutData)
{
RC522_ClearReg(DivIrqReg, 0x04); // 清除CRC中断
RC522_WriteData(CommandReg, PCD_IDLE); // 进入IDLE模式
RC522_SetReg(FIFOLevelReg, 0x80); // 清楚缓冲区
for (uint8_t i=0; i<len; i++)
{
RC522_WriteData(FIFODataReg, Indata[i]); // 写入FIFO
}
RC522_WriteData(CommandReg, PCD_CALCCRC); // 计算CRC模式
for(uint8_t i = 0xFF; i>0; i--)
{
if(RC522_ReadData(DivIrqReg) & 0x04) // 等待CRC计算完成中断
{
break;
}
}
OutData[0] = RC522_ReadData(CRCResultRegL); // 读CRC计算结果
OutData[1] = RC522_ReadData(CRCResultRegM);
}
在sensor_rfid.c文件中添加Card_Select()函数，实现选定卡片功能，函数实现方法与寻卡、防冲撞类似，向RF522寄存器发送数据并等待应答
int8_t Card_Select(uint8_t *card_sn)
{
uint8_t RC522_DataBuffer[MAXRLEN] = {0};
RC522_DataBuffer[0] = PICC_ANTICOLL1; // 选卡命令
RC522_DataBuffer[1] = 0x70; // 表明PCD发送字节数为整7个字节
for(uint8_t i=0; i<4; i++) // 卡ID（4字节）及校验位（1字节）
{
RC522_DataBuffer[i+2] = card_sn[i];
RC522_DataBuffer[6] ^= card_sn[i];
}
CalulateCRC(RC522_DataBuffer, 7, &RC522_DataBuffer[7]); // 计算CRC16
RC522_ClearReg(Status2Reg, 0x08); // 该位表示MIFARE®Crypto1单元已打开，因此与该卡的所有数据通信都已加密
uint32_t OutLen;
int8_t status = RC522_CardCom(PCD_TRANSCEIVE, RC522_DataBuffer, 9, RC522_DataBuffer, &OutLen); // 返回值共24位， 0x08 0xB6 0xDD
if((status == MI_OK)&&(OutLen == 0x18))
{
status = MI_OK;
}
else
{
status = MI_ERR;
}
return status;
}
在sensor_rfid.c文件中添加Card_Validation()函数，实现验证卡的密钥
int8_t Card_Validation(const uint8_t verifymode, const uint8_t address, const uint8_t *key, const uint8_t *cardseries)
{
uint8_t RC522_DataBuffer[MAXRLEN] = {0};
RC522_DataBuffer[0] = verifymode; // 密码验证模式
RC522_DataBuffer[1] = address; //
for (uint8_t i=0; i<6; i++)
{
RC522_DataBuffer[i+2] = key[i]; // 填入密码
}
for (uint8_t i=0; i<4; i++)
{
RC522_DataBuffer[i+8] = cardseries[i]; // 填入卡片序列号
}
uint32_t OutLen;
int8_t status = RC522_CardCom(PCD_AUTHENT, RC522_DataBuffer, 12, RC522_DataBuffer, &OutLen);
if((status != MI_OK) || (!(RC522_ReadData(Status2Reg) & 0x08))) // 该位表示MIFARE®Crypto1单元已打开，因此与该卡的所有数据通信都已加密
{
status = MI_ERR;
}
return status;
}
在sensor_rfid.c文件中添加Card_Read()函数，实现读取卡中的数据
int8_t Card_Read(uint8_t address, uint8_t *Data)
{
uint8_t RC522_DataBuffer[MAXRLEN] = {0};
RC522_DataBuffer[0] = PICC_READ;
RC522_DataBuffer[1] = address;
CalulateCRC(RC522_DataBuffer, 2, &RC522_DataBuffer[2]);
uint32_t OutLen;
int8_t status = RC522_CardCom(PCD_TRANSCEIVE, RC522_DataBuffer, 4, RC522_DataBuffer, &OutLen);
if((status == MI_OK) && (OutLen == 0x90))
{
for (uint8_t i=0; i<16; i++)
{
Data[i] = RC522_DataBuffer[i];
}
}
else
{
status = MI_ERR;
}
return status;
}
在sensor_rfid.c文件中添加Card_Write()函数，实现写数据到IC卡
int8_t Card_Write(uint8_t address, const uint8_t *Data)
{
uint32_t OutLen;
uint8_t RC522_DataBuffer[MAXRLEN] = {0};
RC522_DataBuffer[0] = PICC_WRITE;
RC522_DataBuffer[1] = address;
CalulateCRC(RC522_DataBuffer, 2, &RC522_DataBuffer[2]);
int8_t status = RC522_CardCom(PCD_TRANSCEIVE, RC522_DataBuffer, 4, RC522_DataBuffer, &OutLen);
if((status != MI_OK) || (OutLen != 4) || ((RC522_DataBuffer[0] & 0x0F) != 0x0A))
{
status = MI_ERR;
}
if(status == MI_OK)
{
for(uint8_t i=0; i<16; i++)
{
RC522_DataBuffer[i] = Data[i];
}
CalulateCRC(RC522_DataBuffer, 16, &RC522_DataBuffer[16]);
status = RC522_CardCom(PCD_TRANSCEIVE, RC522_DataBuffer, 18, RC522_DataBuffer, &OutLen);
if((status != MI_OK) || (OutLen != 4) || ((RC522_DataBuffer[0] & 0x0F) != 0x0A))
{
status = MI_ERR;
}
}
return status;
}
在sensor_rfid.c文件中添加RC522_Read_ID()函数，这个函数用于识别IC卡的ID。函数中首先调用PcdRequest()实现寻卡操作，然后调用PcdAnticoll()函数进行防冲撞并将卡ID存储到Card_ID，最后返回状态
// 读ID函数
int8_t RC522_Read_ID(uint8_t *Card_ID)
{
int8_t status = 0;
uint8_t count = CARD_INIT_RETRY_COUNT;
while(Card_Find(PICC_REQALL, Card_ID) != MI_OK && --count);
if(count==0) status = MI_FIND_ERR;
count = CARD_INIT_RETRY_COUNT;
while(Card_Anticoll(Card_ID) != MI_OK && --count);
if(count==0) status = MI_ANTICOLL_ERR;
return status;
}
在sensor_rfid.c文件中添加Card_Adjust()函数，实现数据块的自增自减功能
int8_t Card_Adjust(uint8_t Command, uint8_t block_num, uint32_t value)
{
uint32_t OutLen;
uint8_t RC522_DataBuffer[MAXRLEN] = {0};
RC522_DataBuffer[0] = Command;
RC522_DataBuffer[1] = block_num;
CalulateCRC(RC522_DataBuffer, 2, &RC522_DataBuffer[2]);
// 写入命令和地址
int8_t status = RC522_CardCom(PCD_TRANSCEIVE, RC522_DataBuffer, 4, RC522_DataBuffer, &OutLen);
if((status != MI_OK) || (OutLen != 4) || ((RC522_DataBuffer[0] & 0x0F) != 0x0A))
{
status = MI_ERR;
}
if(status == MI_OK)
{
RC522_DataBuffer[0] = ((uint8_t*)&value)[0];
RC522_DataBuffer[1] = ((uint8_t*)&value)[1];
RC522_DataBuffer[2] = ((uint8_t*)&value)[2];
RC522_DataBuffer[3] = ((uint8_t*)&value)[3];
CalulateCRC(RC522_DataBuffer, 4, &RC522_DataBuffer[4]);
OutLen = 0;
status = RC522_CardCom(PCD_TRANSCEIVE, RC522_DataBuffer, 6, RC522_DataBuffer, &OutLen);
if(status != MI_ERR)
{
status = MI_OK;
}
if(status == MI_OK)
{
RC522_DataBuffer[0] = PICC_TRANSFER; // 保存缓冲区数据
RC522_DataBuffer[1] = block_num;
CalulateCRC(RC522_DataBuffer, 2, &RC522_DataBuffer[2]);
status = RC522_CardCom(PCD_TRANSCEIVE, RC522_DataBuffer, 4, RC522_DataBuffer, &OutLen);
if ((status != MI_OK) || (OutLen != 4) ||((RC522_DataBuffer[0] & 0x0F) != 0x0A))
{
status = MI_ERR;
}
}
}
return status;
}
在sensor_rfid.c文件中添加Card_Init()函数，实现寻卡、防冲撞、选卡以及验证密钥
// 寻卡 防冲撞 选卡 验证密钥
static int8_t Card_Init(const uint8_t block_num, const uint8_t* passwd)
{
uint8_t Data_Buffer[4] = {0};
uint8_t count = CARD_INIT_RETRY_COUNT;
while(Card_Find(PICC_REQALL, Data_Buffer) != MI_OK && --count);
if(count==0) return MI_FIND_ERR;
count = CARD_INIT_RETRY_COUNT;
while(Card_Anticoll(Data_Buffer) != MI_OK && --count);
if(count==0) return MI_ANTICOLL_ERR;
count = CARD_INIT_RETRY_COUNT;
while(Card_Select(Data_Buffer) != MI_OK && --count);
if(count==0) return MI_SELECT_ERR;
count = CARD_INIT_RETRY_COUNT;
while(Card_Validation(PICC_AUTHENT1A, block_num / 4 * 4 + 3, passwd, Data_Buffer) != MI_OK && --count);
if(count==0) return MI_VALIDATION_ERR;
return MI_OK;
}
在sensor_rfid.c文件中添加RFID_Write()函数，实现向卡中写入数据。函数首先调用Card_Init()实现寻卡、防冲撞、选卡以及验证密钥，然后调用RFID_Write()函数实现写数据功能
int8_t RFID_Write(const uint8_t block_num, const uint8_t* passwd, const uint8_t* buffer)
{
if(block_num < 1 || block_num > 63 || block_num % 4 == 3)
{
return MI_PARAM_ERR;
}
int8_t state = Card_Init(block_num, passwd);
if(state != MI_OK)
{
return state;
}
return Card_Write(block_num, buffer);
}
在sensor_rfid.c文件中添加RFID_Read()函数，实现从卡中读出数据
int8_t RFID_Read(const uint8_t block_num, const uint8_t* passwd, uint8_t* buffer)
{
if(block_num < 1 || block_num > 63 || block_num % 4 == 3)
{
return MI_PARAM_ERR;
}
int8_t state = Card_Init(block_num, passwd);
if(state != MI_OK)
{
return state;
}
return Card_Read(block_num, buffer);
}
在sensor_rfid.c文件中添加RFID_Increment()函数，实现给卡中数据充值
int8_t RFID_Increment(const uint8_t block_num, const uint8_t* passwd, uint32_t value)
{
if(block_num < 1 || block_num > 63 || block_num % 4 == 3)
{
return MI_PARAM_ERR;
}
int8_t state = Card_Init(block_num, passwd);
if(state != MI_OK)
{
return state;
}
return Card_Adjust(PICC_INCREMENT, block_num, value);
}
在sensor_rfid.c文件中添加RFID_Decrement()函数，实现给卡中数据扣款
int8_t RFID_Decrement(const uint8_t block_num, const uint8_t* passwd, uint32_t value)
{
if(block_num < 1 || block_num > 63 || block_num % 4 == 3)
{
return MI_PARAM_ERR;
}
int8_t state = Card_Init(block_num, passwd);
if(state != MI_OK)
{
return state;
}
return Card_Adjust(PICC_DECREMENT, block_num, value);
}
在sensor_rfid.c文件中添加RFID_ValueBlock_Init()函数，实现初始化数据块中的数据格式，用来充值和扣款
int8_t RFID_ValueBlock_Init(const uint8_t block_num, const int32_t value, const uint8_t* passwd)
{
uint8_t buffer[16] = {0};
*((int32_t*)buffer+0) = value;
*((int32_t*)buffer+1) = ~value;
*((int32_t*)buffer+2) = value;
buffer[12] = buffer[14] = block_num;
buffer[13] = buffer[15] = ~block_num;
Buzzer_Bi();
return RFID_Write(block_num, passwd, buffer);
}
在main.c文件中引用相关头文件，并定义相关变量
#include "sensor_rfid.h"
#include "bsp_buzzer.h"
#include "bsp_systick.h"
#include "bsp_usart.h"
#include "bsp_spi.h"
extern uint8_t usart1_data;
uint8_t Read_Data[16]; // 读取数据缓冲区
uint8_t Card_ID[4]; // 读取卡的ID
uint8_t Card_DefaultKey[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; // 验证密钥A
int32_t money = 0; // 当前钱数
在main.c文件中定义Error_Display()函数，实现显示错误类型
void Error_Display(int8_t status)
{
switch(status)
{
case -1:
printf("Error!\r\n");
break;
case -2:
printf("Parameter input error!\r\n");
break;
case -3:
printf("Find card error!\r\n");
break;
case -4:
printf("Anti-collision error!\r\n");
break;
case -5:
printf("Selected card error!\r\n");
break;
case -6:
printf("Password verification error!\r\n");
break;
}
}
在main.c文件中定义Money_Increment()函数，实现向卡第4数据块中充值100元并输出充值结果
// 加数据函数
void Money_Increment(void)
{
int8_t status = 0;
status = RFID_Increment(0x04, Card_DefaultKey, 100);
if(status == MI_OK)
{
printf("Increment successfully!!\r\n");
RFID_Read(4, Card_DefaultKey, Read_Data);
money = *(int32_t*)Read_Data;
printf("Money count: %d\r\n", money);
}
else
{
printf("Increment failed, ");
Error_Display(status);
}
}
在main.c文件中定义Money_Decrement()函数，实现向第4数据块卡中扣款100元并输出扣款结果
// 减数据函数
void Money_Decrement(void)
{
int8_t status = 0;
status = RFID_DECREMENT(0x04, Card_DefaultKey, 100);
if(status == MI_OK)
{
printf("Decrement successfully!!\r\n");
RFID_Read(4, Card_DefaultKey, Read_Data);
money = *(int32_t*)Read_Data;
printf("Money count: %d\r\n", money);
}
else
{
printf("Decrement failed, ");
Error_Display(status);
}
}
在main.c文件中定义Read_CardID()函数，实现读取卡的ID并通过串口打印出值
// 读取卡的ID
void Read_CardID(void)
{
int8_t status = 0;
uint32_t ID = 0;
status = RC522_Read_ID(Card_ID);
if(status == MI_OK)
{
ID = *(uint32_t*)Card_ID;
printf("IC ID: 0x%X\r\n", ID);
}
else
{
printf("Read Card ID error, ");
Error_Display(status);
}
}
在main.c文件中定义Fill_Money()函数，实现向IC卡中所有数据块（不包括4）填充数据，并打印出每个扇区中填充成功的数据个数以及所有扇区填充成功的总数
// 向IC卡填充数据函数
void Fill_Money(void)
{
uint8_t Write_Data[16] = {0}; // 写入数据缓冲区
data.blocks_total = 0;
for(uint8_t i=5; i<64; i++)
{
if(i%4 == 3) // 如果是密码数据块 则跳过
{
printf("Writing the %d sector, succeed number is:%d\r\n", i/4, data.blocks_of_sector);
data.blocks_of_sector = 0;
continue;
}
memset(Write_Data, i, 16); // 填入数据到写入缓冲区
if(RFID_Write(i, Card_DefaultKey, Write_Data) == MI_OK)
{
data.blocks_of_sector++; // 当前扇区成功写入次数
data.blocks_total++; // 总写入成功次数
}
else
{
data.blocks_error++;
}
SYSTICK_DelayMs(100);
}
printf("Number of sectors successfully written:%d\r\n", data.blocks_total);
printf("Write Error Number is:%d count\r\n", data.blocks_error);
}
在main.c文件中的main()函数中初始化相应外设，并通过判断串口输入的命令来完成充值、扣款、读取ID以及填充所有扇区的功能
int main()
{
for(uint16_t i=0; i<0xFFFF; i++);
SYSTICK_Init(1); // 滴答定时器初始化
USART1_Init();
Buzzer_Init(); // 蜂鸣器初始化函数调用
SPI_GPIO_Init();
RC522_Init();
printf("**********Operating instructions**********\r\n");
printf("Money count: 0\r\n");
printf("\'+\':Increment 100\r\n");
printf("\'-\':Decrement 100\r\n");
printf("\'1\':Read Card ID\r\n");
printf("\'2\':Write all sectors\r\n");
printf("******************************************\r\n");
RFID_ValueBlock_Init(0x04, money, Card_DefaultKey);
while(1)
{
switch(usart1_data)
{
case '+': // 充值100元
Money_Increment();
break;
case '-': // 扣费100元
Money_Decrement();
break;
case '1': // 读取卡中ID
Read_CardID();
break;
case '2': // 向卡中各扇区写入数据
Fill_Money();
break;
default:
break;
}
usart1_data = 0;
SYSTICK_DelayMs(50);
}
}
现象
将程序下载到开发板中，打开串口调试助手，可以看到窗口中提示可输入命令选项，可以分别输入相应的命令，实现充值、扣款、读取ID以及填充所有扇区的功能。
更多交流欢迎关注作者抖音号：81849645041
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
