1. 全栈程序员必看首页

rfid-rc522使用教程_RFID读写方式是什么

全栈程序员-用户IM • • 未分类

rfid-rc522使用教程_RFID读写方式是什么文章目录1、RC522驱动原理2、手机APP查看卡信息3、驱动移植4、读写卡1、RC522驱动原理2、手机APP查看卡信息这里我参考的这篇博主的文章，讲的还是蛮详细的：https://blog.csdn.net/Ikaros_521/article/details/115958888使用的APP如下所示：可以按照软件操作读取一个卡的信息如下所示，可以看到他是16个扇区，每个扇区有四个块，所以就一共是64块，储存的信息数量是1024byte，计算方式为16416=1024。下面的几页信息如

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺

文章目录

1、RC522驱动原理

我们常见的RC522大概如下所示，PCB部分是主机，然后白色的和绿色的都是IC卡，IC卡可以存储信息，通过靠近PCB主机部分就可以被感应到从而触发主机做出相应的动作，比如读取IC卡信息，写入数据等操作。
在这里插入图片描述
主机模块板载的芯片为MF_RC522，是应用于 13.56MHz 非接触式通信中高集成度读写卡系列芯片中的一员。是 NXP 公司针对“三表”应用推出的一款低 电压、低成本、体积小的非接触式读写卡芯片，是智能仪表和便携 式手持设备研发的较好选择，芯片引脚图如下所示：
在这里插入图片描述
关于他的读写，官方也提供了API函数，可以查询API手册，这里不做具体介绍，网上找到的资料我看大部分都是已经移植好的，而且基本也是同一套的模版。

下面我来介绍下IC卡的原理

首先是工作原理：卡片的电气部分只由一个天线和ASIC组成。天线：卡片的天线是只有几组绕线的线圈，很适于封装到I卡片中。ASIC：卡片的ASIC由一个高速（106KB波特率）的RF接口，一个控制单元和一个8K位EEPROM组成。

那么这个卡他不带电，他是怎么工作的呢？工作原理如下

读写器向M1卡发一组固定频率的电磁波，卡片内有一个LC串联谐振电路，其频率与读写器发射的频率相同，在电磁波的激励下，LC谐振电路产生共振，从而使电容内有了电荷，在这个电容的另一端，接有一个单向导通的电子泵，将电容内的电荷送到另一个电容内储存，当所积累的电荷达到2V时，此电容可做为电源为其它电路提供工作电压，将卡内数据发射出去或接取读写器的数据。

下面再来说下卡片的内部储存信息

卡片容量为8K位EEPROM，分为16个扇区，每个扇区为4块，每块16个字节，以块为存取单位每个扇区有独立的一组密码及访问控制每张卡有唯一序列号，为32位，我们也将16个扇区的64个块按绝对地址编号为063，存贮结构如下图所示：
在这里插入图片描述
这里注意：第0扇区的块0（即绝对地址0块），它用于存放厂商代码，已经固化，不可更改。每个扇区的块0、块1、块2为数据块，可用于存贮数据。

根据官方手册的推荐，一般我们对卡的操作流程如下，这也将在程序中体现出来：
在这里插入图片描述

2、手机APP查看卡信息

这里我参考的这篇博主的文章，讲的还是蛮详细的：https://blog.csdn.net/Ikaros_521/article/details/115958888

使用的APP如下所示：
在这里插入图片描述
可以按照软件操作读取一个卡的信息如下所示，可以看到他是16个扇区，每个扇区有四个块，所以就一共是64块，储存的信息数量是1024byte，计算方式为16416=1024。
在这里插入图片描述
下面的几页信息如下所示：
在这里插入图片描述
因此我们通过这些方法就可以查看卡的数据了，下面的部分我们也将用这个APP来查看我们对卡的操作，包括卡片ID的选择，然后写入的信息等等！

3、驱动移植

先在这里配置我们的SPI的外设，这里除了速率，其他基本上默认即可，这里有的博主说不要设置的太快，这里我实测应该是没有影响的，感觉还是可以正常使用的！
在这里插入图片描述
下面配置下其他的一些引脚，主要是片选信号还有复位引脚
在这里插入图片描述

之后就可以生成代码了，这里我们代码部分以移植为主，主要就是这个读写数据的函数，这里我卡了很久，一直都没有实现成功，如果有看到这篇文章并且实现了的兄弟可以跟我交流下。

这里最终采用的读写函数如下所示，如果是仅仅读写一个位的话，就可以吧senddatanum去掉即可，当然这样写我们主要把senddatanum这个参数设置为1就是读写一个了，这样兼容性更好！
在这里插入图片描述
之后就可以编写读写函数了
在这里插入图片描述
除此之外的其他部分代码都还是兼容的，只要直接复制就行了，我看目前网上大多采用的也是这一套的代码，比较方便，这里可以关注下复位的这个流程，这里我将杜威的过程写成了函数，用起来方便点。
在这里插入图片描述

4、读写卡

这里我们首先读取卡的ID试试
在这里插入图片描述
将程序下载到开发板，可以看到成功读取
在这里插入图片描述
下面我们来进行写卡的操作，大概流程是选中卡片，然后在指定区块写入数据，然后在指定区块读取数据，最后当我们执行完所有操作就可以退出选中，让卡片进入休眠了！
在这里插入图片描述
将程序下载到开发板，可以看到打印的程执行结果是符合我们预期的，效果也是正常的！
在这里插入图片描述
再次用手机读卡，可以看到我们写入的数据如下所示：
在这里插入图片描述

5、源码

RC522.c

/* * RC522.c * * Created on: Mar 23, 2022 * Author: LX */

#include "RC522.h"
#include "stdio.h"

#define RC522_RST_HIGH HAL_GPIO_WritePin(RC522_RST_GPIO_Port, RC522_RST_Pin, GPIO_PIN_SET);
#define RC522_RST_LOW HAL_GPIO_WritePin(RC522_RST_GPIO_Port, RC522_RST_Pin, GPIO_PIN_RESET);

#define RC522_ENABLE HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET);
#define RC522_DISABLE HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET);

extern SPI_HandleTypeDef hspi1;

#define fac_us 72 //时钟频率，单位MHZ

/*微秒级延时函数*/
void delay_us(uint32_t nus)
{ 
   
	uint32_t ticks;
	uint32_t told,tnow,tcnt=0;
	uint32_t reload=SysTick->LOAD;			//LOAD的值
	ticks=nus*fac_us; 						//需要的节拍数
	told=SysTick->VAL;        				//刚进入时的计数器值
	while(1)
	{ 
   
		tnow=SysTick->VAL;
		if(tnow!=told)
		{ 
   
			if(tnow<told)tcnt+=told-tnow;	//这里注意一下SYSTICK是一个递减的计数器就可以了.
			else tcnt+=reload-tnow+told;
			told=tnow;
			if(tcnt>=ticks)break;			//时间超过/等于要延迟的时间,则退出.
		}
	}
}
int32_t SPI_WriteNBytes(SPI_TypeDef* SPIx, uint8_t *p_TxData,uint32_t sendDataNum)
{ 
   
	uint8_t retry=0;
	while(sendDataNum--){ 
   
		while((SPIx->SR&SPI_FLAG_TXE)==0)//等待发送区空
		{ 
   
			retry++;
			if(retry>20000)return -1;
		}
		SPIx->DR=*p_TxData++;//发送一个byte
		retry=0;
		while((SPIx->SR&SPI_FLAG_RXNE)==0)//等待接收完一个byte
		{ 
   
			SPIx->SR = SPIx->SR;
			retry++;
			if(retry>20000)return -1;
		}
		SPIx->DR;
	}
	return 0;
}
int32_t SPI_ReadNBytes(SPI_TypeDef* SPIx, uint8_t *p_RxData,uint32_t readDataNum)
{ 
   
	uint8_t retry=0;
	while(readDataNum--){ 
   
		SPIx->DR = 0xFF;
		while(!(SPIx->SR&SPI_FLAG_TXE)){ 
   
			retry++;
			if(retry>20000)return -1;
		}
		retry = 0;
		while(!(SPIx->SR&SPI_FLAG_RXNE)){ 
   
			retry++;
			if(retry>20000)return -1;
		}
		*p_RxData++ = SPIx->DR;
	}
	return 0;
}
void RC522_Init(void)
{ 
   
	RC522_ENABLE;
	HAL_SPI_Transmit(&hspi1, (uint8_t *)0xaa, sizeof((uint8_t *)0xaa), 0xFF);//启动传输
	RC522_DISABLE;

    HAL_Delay(50);
	PcdReset();//复位RC522读卡器
	HAL_Delay(10);
	PcdReset();//复位RC522读卡器
	HAL_Delay(10);
	PcdAntennaOff();//关闭天线发射
	HAL_Delay(10);
    PcdAntennaOn();//开启天线发射

	printf("RFID-MFRC522 初始化完成\r\nFindCard Starting ...\r\n");  //测试引脚初始化完成
}

//功 能：寻卡
//参数说明: req_code[IN]:寻卡方式
// 0x52 = 寻感应区内所有符合14443A标准的卡
// 0x26 = 寻未进入休眠状态的卡
// pTagType[OUT]：卡片类型代码
// 0x4400 = Mifare_UltraLight
// 0x0400 = Mifare_One(S50)
// 0x0200 = Mifare_One(S70)
// 0x0800 = Mifare_Pro(X)
// 0x4403 = Mifare_DESFire
//返 回: 成功返回MI_OK
char PcdRequest(unsigned char req_code, unsigned char *pTagType)
{ 
   
    char status;
    unsigned int unLen;
    unsigned char ucComMF522Buf[MAXRLEN];

    ClearBitMask(Status2Reg, 0x08);  //清RC522寄存位
    WriteRawRC(BitFramingReg, 0x07); //写RC623寄存器
    SetBitMask(TxControlReg, 0x03);  //置RC522寄存位

    ucComMF522Buf[0] = req_code;

    status = PcdComMF522(PCD_TRANSCEIVE, ucComMF522Buf, 1, ucComMF522Buf, &unLen);
    if ((status == MI_OK) && (unLen == 0x10))
    { 
   
        *pTagType = ucComMF522Buf[0];
        *(pTagType + 1) = ucComMF522Buf[1];
    }
    else
    { 
   
        status = MI_ERR;
    }
    return status;
}
//功 能：防冲撞
//参数说明: pSnr[OUT]:卡片序列号，4字节
//返 回: 成功返回MI_OK
char PcdAnticoll(unsigned char *pSnr)
{ 
   
    char status;
    unsigned char i, snr_check = 0;
    unsigned int unLen;
    unsigned char ucComMF522Buf[MAXRLEN];
    ClearBitMask(Status2Reg, 0x08);
    WriteRawRC(BitFramingReg, 0x00);
    ClearBitMask(CollReg, 0x80);
    ucComMF522Buf[0] = PICC_ANTICOLL1;
    ucComMF522Buf[1] = 0x20;

    status = PcdComMF522(PCD_TRANSCEIVE, ucComMF522Buf, 2, ucComMF522Buf, &unLen);
    if (status == MI_OK)
    { 
   
        for (i = 0; i < 4; i++)
        { 
   
            *(pSnr + i) = ucComMF522Buf[i];
            snr_check ^= ucComMF522Buf[i];
        }
        if (snr_check != ucComMF522Buf[i])
        { 
   
            status = MI_ERR;
        }
    }
    SetBitMask(CollReg, 0x80);
    return status;
}
//功 能：选定卡片
//参数说明: pSnr[IN]:卡片序列号，4字节
//返 回: 成功返回MI_OK
char PcdSelect(unsigned char *pSnr)
{ 
   
    char status;
    unsigned char i;
    unsigned int unLen;
    unsigned char ucComMF522Buf[MAXRLEN];
    ucComMF522Buf[0] = PICC_ANTICOLL1;
    ucComMF522Buf[1] = 0x70;
    ucComMF522Buf[6] = 0;
    for (i = 0; i < 4; i++)
    { 
   
        ucComMF522Buf[i + 2] = *(pSnr + i);
        ucComMF522Buf[6] ^= *(pSnr + i);
    }
    CalulateCRC(ucComMF522Buf, 7, &ucComMF522Buf[7]);
    ClearBitMask(Status2Reg, 0x08);
    status = PcdComMF522(PCD_TRANSCEIVE, ucComMF522Buf, 9, ucComMF522Buf, &unLen);
    if ((status == MI_OK) && (unLen == 0x18))
    { 
   
        status = MI_OK;
    }
    else
    { 
   
        status = MI_ERR;
    }
    return status;
}
//功 能：验证卡片密码
//参数说明: auth_mode[IN]: 密码验证模式
// 0x60 = 验证A密钥
// 0x61 = 验证B密钥
// addr[IN]：块地址
// pKey[IN]：密码
// pSnr[IN]：卡片序列号，4字节
//返 回: 成功返回MI_OK
char PcdAuthState(unsigned char auth_mode, unsigned char addr, unsigned char *pKey, unsigned char *pSnr)
{ 
   
    char status;
    unsigned int unLen;
    unsigned char i, ucComMF522Buf[MAXRLEN];
    ucComMF522Buf[0] = auth_mode;
    ucComMF522Buf[1] = addr;
    for (i = 0; i < 6; i++)
    { 
   
        ucComMF522Buf[i + 2] = *(pKey + i);
    }
    for (i = 0; i < 6; i++)
    { 
   
        ucComMF522Buf[i + 8] = *(pSnr + i);
    }
    status = PcdComMF522(PCD_AUTHENT, ucComMF522Buf, 12, ucComMF522Buf, &unLen);
    if ((status != MI_OK) || (!(ReadRawRC(Status2Reg) & 0x08)))
    { 
   
        status = MI_ERR;
    }
    return status;
}
//功 能：读取M1卡一块数据
//参数说明: addr[IN]：块地址
// p [OUT]：读出的数据，16字节
//返 回: 成功返回MI_OK
char PcdRead(unsigned char addr, unsigned char *pData)
{ 
   
    char status;
    unsigned int unLen;
    unsigned char i, ucComMF522Buf[MAXRLEN];
    ucComMF522Buf[0] = PICC_READ;
    ucComMF522Buf[1] = addr;
    CalulateCRC(ucComMF522Buf, 2, &ucComMF522Buf[2]);

    status = PcdComMF522(PCD_TRANSCEIVE, ucComMF522Buf, 4, ucComMF522Buf, &unLen);
    if ((status == MI_OK) && (unLen == 0x90))
    { 
   
        for (i = 0; i < 16; i++)
        { 
   
            *(pData + i) = ucComMF522Buf[i];
        }
    }
    else
    { 
   
        status = MI_ERR;
    }
    return status;
}
//功 能：写数据到M1卡一块
//参数说明: addr[IN]：块地址
// p [IN]：写入的数据，16字节
//返 回: 成功返回MI_OK
char PcdWrite(unsigned char addr, unsigned char *pData)
{ 
   
    char status;
    unsigned int unLen;
    unsigned char i, ucComMF522Buf[MAXRLEN];
    ucComMF522Buf[0] = PICC_WRITE;
    ucComMF522Buf[1] = addr;
    CalulateCRC(ucComMF522Buf, 2, &ucComMF522Buf[2]);
    status = PcdComMF522(PCD_TRANSCEIVE, ucComMF522Buf, 4, ucComMF522Buf, &unLen);
    if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
    { 
   
        status = MI_ERR;
    }
    if (status == MI_OK)
    { 
   
        for (i = 0; i < 16; i++)
        { 
   
            ucComMF522Buf[i] = *(pData + i);
        }
        CalulateCRC(ucComMF522Buf, 16, &ucComMF522Buf[16]);

        status = PcdComMF522(PCD_TRANSCEIVE, ucComMF522Buf, 18, ucComMF522Buf, &unLen);
        if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
        { 
   
            status = MI_ERR;
        }
    }
    return status;
}
//功 能：扣款和充值
//参数说明: dd_mode[IN]：命令字
// 0xC0 = 扣款
// 0xC1 = 充值
// addr[IN]：钱包地址
// pValue[IN]：4字节增(减)值，低位在前
//返 回: 成功返回MI_OK
char PcdValue(unsigned char dd_mode, unsigned char addr, unsigned char *pValue)
{ 
   
    char status;
    unsigned int unLen;
    unsigned char i, ucComMF522Buf[MAXRLEN];
    ucComMF522Buf[0] = dd_mode;
    ucComMF522Buf[1] = addr;
    CalulateCRC(ucComMF522Buf, 2, &ucComMF522Buf[2]);
    status = PcdComMF522(PCD_TRANSCEIVE, ucComMF522Buf, 4, ucComMF522Buf, &unLen);

    if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
    { 
   
        status = MI_ERR;
    }
    if (status == MI_OK)
    { 
   
        for (i = 0; i < 16; i++)
        { 
   
            ucComMF522Buf[i] = *(pValue + i);
        }
        CalulateCRC(ucComMF522Buf, 4, &ucComMF522Buf[4]);
        unLen = 0;
        status = PcdComMF522(PCD_TRANSCEIVE, ucComMF522Buf, 6, ucComMF522Buf, &unLen);
        if (status != MI_ERR)
        { 
   
            status = MI_OK;
        }
    }
    if (status == MI_OK)
    { 
   
        ucComMF522Buf[0] = PICC_TRANSFER;
        ucComMF522Buf[1] = addr;
        CalulateCRC(ucComMF522Buf, 2, &ucComMF522Buf[2]);

        status = PcdComMF522(PCD_TRANSCEIVE, ucComMF522Buf, 4, ucComMF522Buf, &unLen);

        if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
        { 
   
            status = MI_ERR;
        }
    }
    return status;
}
//功 能：备份钱包
//参数说明: sourceaddr[IN]：源地址
// goaladdr[IN]：目标地址
//返 回: 成功返回MI_OK
char PcdBakValue(unsigned char sourceaddr, unsigned char goaladdr)
{ 
   
    char status;
    unsigned int unLen;
    unsigned char ucComMF522Buf[MAXRLEN];
    ucComMF522Buf[0] = PICC_RESTORE;
    ucComMF522Buf[1] = sourceaddr;
    CalulateCRC(ucComMF522Buf, 2, &ucComMF522Buf[2]);
    status = PcdComMF522(PCD_TRANSCEIVE, ucComMF522Buf, 4, ucComMF522Buf, &unLen);
    if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
    { 
   
        status = MI_ERR;
    }
    if (status == MI_OK)
    { 
   
        ucComMF522Buf[0] = 0;
        ucComMF522Buf[1] = 0;
        ucComMF522Buf[2] = 0;
        ucComMF522Buf[3] = 0;
        CalulateCRC(ucComMF522Buf, 4, &ucComMF522Buf[4]);
        status = PcdComMF522(PCD_TRANSCEIVE, ucComMF522Buf, 6, ucComMF522Buf, &unLen);
        if (status != MI_ERR)
        { 
   
            status = MI_OK;
        }
    }
    if (status != MI_OK)
    { 
   
        return MI_ERR;
    }
    ucComMF522Buf[0] = PICC_TRANSFER;
    ucComMF522Buf[1] = goaladdr;
    CalulateCRC(ucComMF522Buf, 2, &ucComMF522Buf[2]);
    status = PcdComMF522(PCD_TRANSCEIVE, ucComMF522Buf, 4, ucComMF522Buf, &unLen);
    if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
    { 
   
        status = MI_ERR;
    }
    return status;
}
//功 能：命令卡片进入休眠状态
//返 回: 成功返回MI_OK
char PcdHalt(void)
{ 
   
    // char status;
    unsigned int unLen;
    unsigned char ucComMF522Buf[MAXRLEN];

    ucComMF522Buf[0] = PICC_HALT;
    ucComMF522Buf[1] = 0;
    CalulateCRC(ucComMF522Buf, 2, &ucComMF522Buf[2]);

    PcdComMF522(PCD_TRANSCEIVE, ucComMF522Buf, 4, ucComMF522Buf, &unLen);

    return MI_OK;
}
//用MF522计算CRC16函数
void CalulateCRC(unsigned char *pIndata, unsigned char len, unsigned char *pOutData)
{ 
   
    unsigned char i, n;
    ClearBitMask(DivIrqReg, 0x04);
    WriteRawRC(CommandReg, PCD_IDLE);
    SetBitMask(FIFOLevelReg, 0x80);
    for (i = 0; i < len; i++)
    { 
   
        WriteRawRC(FIFODataReg, *(pIndata + i));
    }
    WriteRawRC(CommandReg, PCD_CALCCRC);
    i = 0xFF;
    do
    { 
   
        n = ReadRawRC(DivIrqReg);
        i--;
    } while ((i != 0) && !(n & 0x04));
    pOutData[0] = ReadRawRC(CRCResultRegL);
    pOutData[1] = ReadRawRC(CRCResultRegM);
}
//功 能：复位RC522
//返 回: 成功返回MI_OK
char PcdReset(void)
{ 
   
	RC522_RST_HIGH;
    delay_us(10);
    RC522_RST_LOW;
    HAL_Delay(60);
    RC522_RST_HIGH;
    delay_us(500);
    WriteRawRC(CommandReg, PCD_RESETPHASE);
    HAL_Delay(2);

    WriteRawRC(ModeReg, 0x3D);
    WriteRawRC(TReloadRegL, 30);
    WriteRawRC(TReloadRegH, 0);
    WriteRawRC(TModeReg, 0x8D);
    WriteRawRC(TPrescalerReg, 0x3E);
    WriteRawRC(TxAutoReg, 0x40);

    ClearBitMask(TestPinEnReg, 0x80);
    WriteRawRC(TxAutoReg, 0x40);

    return MI_OK;
}
//功 能：读RC632寄存器
//参数说明：Address[IN]:寄存器地址
//返 回：读出的值
unsigned char ReadRawRC(unsigned char Address)
{ 
   
    unsigned char ucAddr;
    unsigned char ucResult = 0;
    ucAddr = ((Address << 1) & 0x7E) | 0x80;
    HAL_Delay(1);
    RC522_ENABLE;
    SPI_WriteNBytes(SPI1, &ucAddr, 1);  //向总线写多个数据
    SPI_ReadNBytes(SPI1, &ucResult, 1); //向总线读多个数据
// HAL_SPI_Transmit(&hspi1,&ucAddr,1,0xff);
// HAL_SPI_Receive(&hspi1,&ucResult,1,0xff);
// while(HAL_SPI_Transmit(&hspi1,&ucAddr,1,0xff) == HAL_OK);
// while(HAL_SPI_Receive(&hspi1,&ucResult,1,0xff) == HAL_OK);
    RC522_DISABLE;
    return ucResult;
}
//功 能：写RC632寄存器
//参数说明：Address[IN]:寄存器地址
// value[IN]:写入的值
void WriteRawRC(unsigned char Address, unsigned char value)
{ 
   
    unsigned char ucAddr;
    uint8_t write_buffer[2] = { 
   0};
    ucAddr = ((Address << 1) & 0x7E);
    write_buffer[0] = ucAddr;
    write_buffer[1] = value;
    HAL_Delay(1);
    RC522_ENABLE;
    SPI_WriteNBytes(SPI1, write_buffer, 2);
// HAL_SPI_Transmit(&hspi1,write_buffer,2,0xff);
// while(HAL_SPI_Transmit(&hspi1,write_buffer,2,0xff) == HAL_OK);
    RC522_DISABLE;
}
//功 能：置RC522寄存器位
//参数说明：reg[IN]:寄存器地址
// mask[IN]:置位值
void SetBitMask(unsigned char reg, unsigned char mask)
{ 
   
    char tmp = 0x0;
    tmp = ReadRawRC(reg);        //读RC632寄存器
    WriteRawRC(reg, tmp | mask); // set bit mask
}
//功 能：清RC522寄存器位
//参数说明：reg[IN]:寄存器地址
// mask[IN]:清位值
void ClearBitMask(unsigned char reg, unsigned char mask)
{ 
   
    char tmp = 0x0;
    tmp = ReadRawRC(reg);
    WriteRawRC(reg, tmp & ~mask); // clear bit mask
}
//功 能：通过RC522和ISO14443卡通讯
//参数说明：Command[IN]:RC522命令字
// pIn [IN]:通过RC522发送到卡片的数据
// InLenByte[IN]:发送数据的字节长度
// pOut [OUT]:接收到的卡片返回数据
// *pOutLenBit[OUT]:返回数据的位长度
char PcdComMF522(unsigned char Command,
                 unsigned char *pInData,
                 unsigned char InLenByte,
                 unsigned char *pOutData,
                 unsigned int *pOutLenBit)
{ 
   
    char status = MI_ERR;
    unsigned char irqEn = 0x00;
    unsigned char waitFor = 0x00;
    unsigned char lastBits;
    unsigned char n;
    unsigned int i;
    switch (Command)
    { 
   
    case PCD_AUTHENT:
        irqEn = 0x12;
        waitFor = 0x10;
        break;
    case PCD_TRANSCEIVE:
        irqEn = 0x77;
        waitFor = 0x30;
        break;
    default:
        break;
    }
    WriteRawRC(ComIEnReg, irqEn | 0x80);
    ClearBitMask(ComIrqReg, 0x80);
    WriteRawRC(CommandReg, PCD_IDLE);
    SetBitMask(FIFOLevelReg, 0x80);
    for (i = 0; i < InLenByte; i++)
    { 
   
        WriteRawRC(FIFODataReg, pInData[i]);
    }
    WriteRawRC(CommandReg, Command);
    if (Command == PCD_TRANSCEIVE)
    { 
   
        SetBitMask(BitFramingReg, 0x80);
    }
    i = 800;
    do
    { 
   
        n = ReadRawRC(ComIrqReg);
        i--;
    } while ((i != 0) && !(n & 0x01) && !(n & waitFor));
    ClearBitMask(BitFramingReg, 0x80);
    if (i != 0)
    { 
   
        if (!(ReadRawRC(ErrorReg) & 0x1B))
        { 
   
            status = MI_OK;
            if (n & irqEn & 0x01)
            { 
   
                status = MI_NOTAGERR;
            }
            if (Command == PCD_TRANSCEIVE)
            { 
   
                n = ReadRawRC(FIFOLevelReg);
                lastBits = ReadRawRC(ControlReg) & 0x07;
                if (lastBits)
                { 
   
                    *pOutLenBit = (n - 1) * 8 + lastBits;
                }
                else
                { 
   
                    *pOutLenBit = n * 8;
                }
                if (n == 0)
                { 
   
                    n = 1;
                }
                if (n > MAXRLEN)
                { 
   
                    n = MAXRLEN;
                }
                for (i = 0; i < n; i++)
                { 
   
                    pOutData[i] = ReadRawRC(FIFODataReg);
                }
            }
        }
        else
        { 
   
            status = MI_ERR;
        }
    }
    SetBitMask(ControlReg, 0x80); // stop timer now
    WriteRawRC(CommandReg, PCD_IDLE);
    return status;
}
//开启天线
//每次启动或关闭天险发射之间应至少有1ms的间隔
void PcdAntennaOn(void)
{ 
   
    unsigned char i;
    i = ReadRawRC(TxControlReg);
    if (!(i & 0x03))
    { 
   
        SetBitMask(TxControlReg, 0x03);
    }
}
//关闭天线
void PcdAntennaOff(void)
{ 
   
    ClearBitMask(TxControlReg, 0x03);
}

void RC522_Config(unsigned char Card_Type)
{ 
   
    ClearBitMask(Status2Reg, 0x08);
    WriteRawRC(ModeReg, 0x3D);
    WriteRawRC(RxSelReg, 0x86);
    WriteRawRC(RFCfgReg, 0x7F);
    WriteRawRC(TReloadRegL, 30);
    WriteRawRC(TReloadRegH, 0);
    WriteRawRC(TModeReg, 0x8D);
    WriteRawRC(TPrescalerReg, 0x3E);
    HAL_Delay(5);
    PcdAntennaOn();
}

RC522.h

/* * RC522.h * * Created on: Mar 23, 2022 * Author: LX */

#ifndef RC522_H_
#define RC522_H_

#include "main.h"

#define PCD_IDLE 0x00 //取消当前命令
#define PCD_AUTHENT 0x0E //验证密钥
#define PCD_RECEIVE 0x08 //接收数据
#define PCD_TRANSMIT 0x04 //发送数据
#define PCD_TRANSCEIVE 0x0C //发送并接收数据
#define PCD_RESETPHASE 0x0F //复位
#define PCD_CALCCRC 0x03 //CRC计算
#define PICC_REQIDL 0x26 //寻天线区内未进入休眠状态
#define PICC_REQALL 0x52 //寻天线区内全部卡
#define PICC_ANTICOLL1 0x93 //防冲撞
#define PICC_ANTICOLL2 0x95 //防冲撞
#define PICC_AUTHENT1A 0x60 //验证A密钥
#define PICC_AUTHENT1B 0x61 //验证B密钥
#define PICC_READ 0x30 //读块
#define PICC_WRITE 0xA0 //写块
#define PICC_DECREMENT 0xC0 //扣款
#define PICC_INCREMENT 0xC1 //充值
#define PICC_RESTORE 0xC2 //调块数据到缓冲区
#define PICC_TRANSFER 0xB0 //保存缓冲区中数据
#define PICC_HALT 0x50 //休眠

#define DEF_FIFO_LENGTH 64 //FIFO size=64byte

// PAGE 0
#define RFU00 0x00
#define CommandReg 0x01
#define ComIEnReg 0x02
#define DivlEnReg 0x03
#define ComIrqReg 0x04
#define DivIrqReg 0x05
#define ErrorReg 0x06
#define Status1Reg 0x07
#define Status2Reg 0x08
#define FIFODataReg 0x09
#define FIFOLevelReg 0x0A
#define WaterLevelReg 0x0B
#define ControlReg 0x0C
#define BitFramingReg 0x0D
#define CollReg 0x0E
#define RFU0F 0x0F
// PAGE 1
#define RFU10 0x10
#define ModeReg 0x11
#define TxModeReg 0x12
#define RxModeReg 0x13
#define TxControlReg 0x14
#define TxAutoReg 0x15
#define TxSelReg 0x16
#define RxSelReg 0x17
#define RxThresholdReg 0x18
#define DemodReg 0x19
#define RFU1A 0x1A
#define RFU1B 0x1B
#define MifareReg 0x1C
#define RFU1D 0x1D
#define RFU1E 0x1E
#define SerialSpeedReg 0x1F
// PAGE 2
#define RFU20 0x20
#define CRCResultRegM 0x21
#define CRCResultRegL 0x22
#define RFU23 0x23
#define ModWidthReg 0x24
#define RFU25 0x25
#define RFCfgReg 0x26
#define GsNReg 0x27
#define CWGsCfgReg 0x28
#define ModGsCfgReg 0x29
#define TModeReg 0x2A
#define TPrescalerReg 0x2B
#define TReloadRegH 0x2C
#define TReloadRegL 0x2D
#define TCounterValueRegH 0x2E
#define TCounterValueRegL 0x2F
// PAGE 3
#define RFU30 0x30
#define TestSel1Reg 0x31
#define TestSel2Reg 0x32
#define TestPinEnReg 0x33
#define TestPinValueReg 0x34
#define TestBusReg 0x35
#define AutoTestReg 0x36
#define VersionReg 0x37
#define AnalogTestReg 0x38
#define TestDAC1Reg 0x39
#define TestDAC2Reg 0x3A
#define TestADCReg 0x3B
#define RFU3C 0x3C
#define RFU3D 0x3D
#define RFU3E 0x3E
#define RFU3F 0x3F

#define MI_OK 0
#define MI_NOTAGERR 1 //(-1)
#define MI_ERR 2 //(-2)

#define MAXRLEN 18



void RC522_Init(void);
char PcdRequest(unsigned char req_code,unsigned char *pTagType);
char PcdAnticoll(unsigned char *pSnr);
char PcdSelect(unsigned char *pSnr);
char PcdAuthState(unsigned char auth_mode,unsigned char addr,unsigned char *pKey,unsigned char *pSnr);
char PcdRead(unsigned char addr,unsigned char *pData);
char PcdWrite(unsigned char addr,unsigned char *pData);
char PcdValue(unsigned char dd_mode,unsigned char addr,unsigned char *pValue);
char PcdBakValue(unsigned char sourceaddr, unsigned char goaladdr);
char PcdHalt(void);
void CalulateCRC(unsigned char *pIndata,unsigned char len,unsigned char *pOutData);
char PcdReset(void);
unsigned char ReadRawRC(unsigned char Address);
void WriteRawRC(unsigned char Address, unsigned char value);
void SetBitMask(unsigned char reg,unsigned char mask);
void ClearBitMask(unsigned char reg,unsigned char mask);
char PcdComMF522(unsigned char Command,
                 unsigned char *pInData,
                 unsigned char InLenByte,
                 unsigned char *pOutData,
                 unsigned int  *pOutLenBit);
void PcdAntennaOn(void);
void PcdAntennaOff(void);
void RC522_Config(unsigned char Card_Type);

#endif /* RC522_H_ */
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/191913.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权 正版激活】： 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

赞 (0)
全栈程序员-用户IM全栈程序员-用户IM
0 0


相关推荐

  • <span>图书馆管理系统程序设计</span>

    图书馆管理系统程序设计

    图书馆管理系统程序设计

    全栈程序员-用户IM 全栈程序员-用户IM
    2021年11月18日
  • eclipse如何使用svn_eclipse中的svn怎么找到

    eclipse如何使用svn_eclipse中的svn怎么找到

    eclipse如何使用svn_eclipse中的svn怎么找到   插件安装：name:   svn                         url:   http://subclipse.tigris.org/update   svn服务器地址：svn://123.127.105.190/repos  

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年9月26日
  • fast known when vm/docker failover to another machine (Linux exp) docker

    fast known when vm/docker failover to another machine (Linux exp)

    fast known when vm/docker failover to another machine (Linux exp)

    全栈程序员-用户IM 全栈程序员-用户IM
    2021年9月13日
  • 服务降级和服务熔断

    服务降级和服务熔断

    服务降级和服务熔断转载自：https://blog.csdn.net/llianlianpay/article/details/79768890 服务熔断  在微服务架构中，微服务之间的数据交互通过远程调用完成，微服务A调用微服务B和微服务C，微服务B和微服务C又调用其它的微服务，此时如果链路上某个微服务的调用响应时间过长或者不可用，那么对微服务A的调用就会占用越来越多的系统资源，进而引起系统崩溃，导致“雪崩…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年6月7日
  • Web安全：概述_逆向和Web安全

    Web安全：概述_逆向和Web安全

    Web安全：概述_逆向和Web安全文章目录浏览器安全同源策略多进程结构沙箱恶意网址拦截跨站脚本攻击XSS定义示例分类浏览器安全同源策略浏览器的同源策略，限制了来自不同源的“document”或脚本对当前“document”的读取或修改。影响源的因素有：host、子域名、端口、协议等。多进程结构将浏览器的各个功能模块分开，各个浏览器实例分开，这样若一个进程崩溃，也不会影响到其他进程。GoogleChrome是第一个采取多进程架构的浏览器，其主要进程包括：浏览器进程、渲染进程、插件进程、扩展进程等。其中插件进程如flash、ja

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年9月14日
  • tomcat服务器监控工具之probe「建议收藏」

    tomcat服务器监控工具之probe「建议收藏」

    tomcat服务器监控工具之probe「建议收藏」前言：今天把公司的一台tomcat服务器进行了迁移，为了查看在使用过程中的详细信息，在网上搜索了很多关于web服务器的监控软件，最后拟定使用probe这个开源并且功能也很完善的一款工具接下来介绍一下使用方法与安装技巧一、简介psi-probe是lambdaprobe的一个分支版本，用于对Tomcat进行监控，比tomcat的manager强大很多。psi就是一个形如叉子的符

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年5月29日

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号