stm32rc522驱动代码标准库移植到HAL库

已于 2024-08-21 17:31:45 修改
阅读量401 收藏 5
点赞数 3
文章标签： stm32 嵌入式硬件 单片机
于 2024-08-21 17:14:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74950972/article/details/141397900
版权

     

RC522 模块概述

  • 芯片型号: RC522
  • 工作频率: 13.56 MHz
  • 通信接口: 支持 SPI、I2C 和 UART 接口
  • 通信协议: ISO/IEC 14443 A/MIFARE
  • 电源电压: 3.3V

模块组成

  • 射频天线: 用于发送和接收 RFID 信号。
  • 主芯片: 处理 RFID 信号，执行读写操作。
  • 接口引脚: 用于与微控制器或其他设备通信。

常见功能

  • 读取 RFID 卡: 可以读取符合 ISO/IEC 14443 A/MIFARE 标准的 RFID 卡上的数据。
  • 写入 RFID 卡: 支持向 RFID 卡中写入数据（仅限于特定类型的卡片）。
  • 与微控制器通信: 通过 SPI、I2C 或 UART 接口与微控制器进行通信。

接线与通信

1. SPI 接口接线
  • SDA (CS): 选择信号
  • SCK: 时钟信号
  • MOSI: 主设备输出从设备输入
  • MISO: 主设备输入从设备输出
  • IRQ: 中断请求（可选）
  • GND: 地线
  • RST: 复位
  • 3.3V: 电源
2. I2C 接口接线
  • SDA: 数据线
  • SCL: 时钟线
  • GND: 地线
  • RST: 复位
  • 3.3V: 电源

    前段时间为做校园热水管理系统，我第一次接触rc522这款芯片，当时将标准库移植为HAL库对于我这种小白来说比较头大，为了节约时间我将用cubemx进行配置。

对spi1进行配置如下

RC522.h 

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

#ifndef RC522_H_
#define RC522_H_

#include "main.h"

#define RC522_RST_Pin      GPIO_PIN_11
#define RC522_RST_GPIO_Port     GPIOA
#define RC522_GPIO_Reset_CLK_ENABLE() \
    do { __HAL_RCC_GPIOA_CLK_ENABLE(); } while(0)

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

#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);
								 void delay_us(uint32_t nus);

#endif /* RC522_H_ */

RC522.c文件

/*
 * RC522.c
 *sda-a4 sck-a5 mosi-a7 mis0-a6
 *  Created on: Mar 23, 2022
 *      Author: LX
 */

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






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(uint8_t req_code, uint8_t  *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();
}

我只做了寻卡和防碰撞 读取卡号，写入和读取可以看手册。

int main(void)
{
  /* USER CODE BEGIN 1 */
		uint16_t time = 0;
	 uint8_t Judge=0;
  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_SPI1_Init();
  MX_USART1_UART_Init();
  MX_TIM1_Init();
  MX_TIM3_Init();
  MX_TIM4_Init();
  MX_TIM5_Init();
  MX_USART2_UART_Init();
  MX_TIM2_Init();
  /* USER CODE BEGIN 2 */
	RC522_Init();
	LCD_Init();//LCD初始化
	LCD_Fill(0,0,LCD_W,LCD_H,WHITE);

	
	HAL_TIM_Base_Start_IT(&htim3 );
	HAL_TIM_PWM_Start(&htim3 ,TIM_SLAVEMODE_GATED);
	HAL_TIM_Base_Start(&htim2);
 
	
	HAL_UART_Receive_IT(&huart2,uart_buf, 1);
	do
	{
		Judge = esp_Init();
		sprintf((char *)str,"error code:%d",Judge);
    printf ("ok=%d",Judge );		
	  //OLED_ShowString(0,2,str,16);
	}
	while(Judge);  //连接阿里云直到成功
	sprintf((char *)str, "Ali-Cloud OK!");
  printf ("l=%d",EspPUB());
	HAL_Delay(500);
  
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
		 EspPUB(water ,debit);
	     HAL_Delay(5);
		 LCD_ShowChinese(40,10,"智能水卡",RED,WHITE,16,0);
		 LCD_ShowChinese(5,50,"卡号",RED,WHITE,16,0);
		 LCD_ShowChinese(5,80,"姓名",RED,WHITE,16,0);
		 LCD_ShowChinese(5,110,"用水量",RED,WHITE,16,0);
	     LCD_ShowChinese(5,140,"扣费金额",RED,WHITE,16,0);
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
		HAL_Delay(10);
		if(MI_OK==PcdRequest(0x26,Card_Type1))//x寻卡
		{
					uint16_t cardType=(Card_Type1[0]<<8)|Card_Type1[1];
					printf ("卡类型(0x%04x)\r\n",cardType);
					switch(cardType)
					{
								case 0x4400:
										printf("\r\nMifare UltraLight\r\n");
										break;
								case 0x0400:
										printf("\r\nMifare One(S50)\r\n");
										break;
								case 0x0200:
										printf("\r\nMifare One(S70)\r\n");
										break;
								case 0x0800:
										printf("\r\nMifare Pro(X)\r\n");
										break;
								case 0x4403:
										printf("\r\nMifare DESFire\r\n");
										break;
								default:
										printf("\r\nUnknown Card\r\n");
										break;	
					
					}
			status=PcdAnticoll(Card_ID);
			if(status !=MI_OK)
			{
				  printf("Anticll Error\r\n");
				  counter=0;
			
			}
			else
			{
				    printf("卡号: 
 %02X%02X%02X%02X\r\n",Card_ID[0],Card_ID[1],Card_ID[2],Card_ID[3]); //打印卡的UID
				    k=Card_ID[0];
				    printf ("k=%d\r\t",k);
				
					  sprintf(ID,"%02X%02X%02X%02X",Card_ID[0],Card_ID[1],Card_ID[2],Card_ID[3]);
							
					  LCD_ShowString(60,50,ID,RED,WHITE,16,0);
				      floge ++;
			          if(floge >2)
					  floge =0;
					   printf ("floge=%d\r\t",floge);
//					   if(strcmp(ID,"232075E4")==0||strcmp(ID,"C7D22A65")==0)
//						{
//							
//							if(strcmp(ID,"232075E4")==0)
//							{
//								LCD_ShowChinese(50,80,"张三",RED,WHITE,16,0);
//							}
//							if(strcmp(ID,"C7D22A65")==0)
//							{
//								LCD_ShowChinese(50,80,"李四",RED,WHITE,16,0);
//							}
//								LCD_ShowString(40,80,":",RED,WHITE,16,0);
//								 water=counter/450;
//							  debit=10-(counter/4500)+Lock;
//								LCD_ShowFloatNum1(90,110, water,3,RED,WHITE,16);
//								LCD_ShowFloatNum1(90,140 ,counter/4500,3,RED,WHITE,16);
//							
//								HAL_GPIO_WritePin (GPIOA,GPIO_PIN_1,GPIO_PIN_RESET);//打开继电器
//								HAL_GPIO_WritePin (GPIOA,GPIO_PIN_8,GPIO_PIN_RESET);
//								counter=__HAL_TIM_GET_COUNTER(&htim2);
//								printf("num=%.2f\r\n",counter/45000);
//						}
			}
		
		}
			status=PcdSelect(Card_ID);
		    if(status !=MI_OK)
			{
				  printf("select card Error\r\n");
				  k=0;
			}
			else 
			{
				printf("select card ok\r\n");
			    status=PcdAuthState(PICC_AUTHENT1A,5,Card_KEY,(Card_ID));
				if(status ==MI_OK)
				{
					printf("成功\r\n");
					Add_Money[0] = 0x01;    //为充值金额    //金额转化
				
				
				}
				
//				memset(Card_ID,1,4);
//				memset(Card_Data,1,4);
				Card_Data[0]=0xaa;
				
				 status=PcdWrite(2,dat);
				
				status=PcdWrite(6,Card_Data);
				if(status !=MI_OK)
				{
					printf("写入 Error\r\n");
					//continue;
				
				}
				
				
//				memset(Card_ID,0,16);//清零
				delay_us (8);
				status=PcdRead(6,Card_Data );//写入数据
				status=PcdRead(2,dat );//写入数据
				if(status !=MI_OK)
				{
					printf("读卡 Error\r\n");
					//continue;
				}
				if(status ==MI_OK)
					{
						int i;
						for(i=0;i<16;i++)
						{
							printf ("%02x",Card_Data[i]);
							printf ("%s",dat);
						
						}
						printf ("\r\t");
					
					}
					memset(Card_Data ,0,16);
					PcdHalt ();//卡休眠
  }
			
	
	      if(floge ==1)
					counter=__HAL_TIM_GET_COUNTER(&htim2);
					else
					__HAL_TIM_GET_COUNTER(&htim2)=0;
					dsplay1 ();
					printf ("counter=%d",counter);
					//HAL_Delay(5000);
}
		
	  HAL_GPIO_WritePin(GPIOC,GPIO_PIN_1,GPIO_PIN_SET);
	  HAL_Delay(500);
	  HAL_GPIO_WritePin(GPIOC,GPIO_PIN_1,GPIO_PIN_RESET);
  /* USER CODE END 3 */
}

胭城云雨
关注
STM32F0 HAL库版本RC523，RC522 读取IC卡卡号，使用SPI通信
09-28
使用CubeMX生成的HAL库，驱动RC523读取IC卡卡号，亲测可用，芯片型号是STM32F030F4，采用片上SPI通信，已经可以读到卡号
基于STM32HAL库，RC522（RFID）模块读写驱动，无线IC卡读写
plmm__的博客
07-26 6208
基于STM32HAL库，RC522模块读写驱动，无线IC卡读写
RFID射频(RC522)模块
01-26
这是一个STM 32F 103 ,RFID射频(RC522)模块程序，分享给大家参考，有详细的注释
005_STM32程序移植之_RC522读卡模块
08-24
视频演示地址：https://v.youku.com/v_show/id_XMzc3MTcyNjE4MA==.html?spm=a2h1n.8251843.playList.5!6~5~A&f=51844923&o=1
基于HAL库STM32+RC522读写卡程序 调试完成
03-31
用hal库开发的stm32f103re RC522读写程序 SPI通讯 可实现对卡类型识别 读写等操作
基于STM32 RC522射频模块驱动程序(HAL库)
03-18
STM32 RC522射频模块驱动...综上所述，STM32 RC522驱动程序开发涉及STM32的HAL库使用、SPI通信、中断处理、寄存器配置、防碰撞算法以及卡片操作等多个方面的知识，通过"RC522_TEST"文件可以进一步学习和实践这些技术。
STM32HAL库RFID-RC522驱动
11-10
STM32HAL库RFID-RC522驱动是一个针对STM32微控制器的硬件抽象层（HAL）库实现，用于操作RFID模块RC522。RC522是一种基于MI-FRIE1标准的非接触式IC卡读写器芯片，常用于门禁系统、电子支付、数据传输等应用。STM32HAL...
005_STM32程序移植之_RC522读卡模块_单片机；RC522_STM32F103_stm32rc522_stm32f10
09-30
首先，移植RC522驱动到STM32F103需要理解MFRC522与微控制器之间的通信协议。MFRC522通常使用SPI（串行外围接口）进行通信，这是一种全双工、同步的串行通信协议。在STM32F103上，你需要配置SPI接口，包括设置时钟...
移植到STM32的MFRC522底层驱动程序
03-28
最近使用MFRC522无线射频卡模块，淘宝店家提供的资料只有C51和MSP430的程序，我将他们的底层驱动移植到了STM32F407上面，使用的HAL库，Cube配置， 博客链接 ：...
RC522 RFID射频模块
04-29
RC522 RFID射频模块（PCB+原理图+RC522原厂代码等） RC522原理图+PCB，用AD软件打开
STM32模拟SPI总线读写RFID模块RC522
Pegasus的软件博客
01-16 3843
RC522是一款NXP 公司的支持ISO14443A协议的高频（13.56MHz）RFID射频芯片。RFID有ID和IC两种卡应用类型，RC522属于IC卡的应用类型。NFC则属于增强的IC卡类型，支持双向通信和更多类型的协议。ID卡在制卡时写入一次后，以后只能读取不能写入，常见的Mango卡工作频率为125KHz，所以也叫低频卡，支持ISO 18000-2协议。常见的ID卡右下角有一串打印数字（由ID前十位和ID后八位组成）：IC卡在发卡时写入信息后，以后通过密码可以读取也可以写入。
STM32——NFC门禁模块（RC522）
最新发布
2401_85013826的博客
05-17 741
/先读回寄存器的值。//先读回寄存器的值。* 返 回 值：-status：错误代码(MFRC_OK、MFRC_NOTAGERR、MFRC_ERR)AddrByte = ((addr
STM32F103RCT6(基于HAL库)+RC522RFID模块开发读写模块
weixin_70603176的博客
08-30 1162
/将数组Uart_Data_Buf中的数据转交给Uart_Data。//验证密码(密码A和密码B)
RFID RC522 c8t6
BAOLI_LONG的博客
09-09 703
RC522驱动
STM32 （基于HAL库）MFRC-522 无线射频IC卡驱动（RFID）
weixin_56565733的博客
12-19 9131
STM32C8T6 RCC522 HAL库驱动： RC522工作原理: 支持SPI,I2C和UART接口，主要采用SPI接口。 寻卡---------->防冲突---------->选卡--------->操作卡 寻卡需要发送一些命令，比如接收数据，发送数据，验证秘钥，复位等一些命令 初始化天线 防冲突操作就是将防冲突命令通过PcdComMF522函数与PICC卡进行交互。防冲突命令是两个字节，其中第一字节为Mifare_One卡的防冲突命令字PICC_ANTICOLL1 （0x93），第
通过Arduino的RFID(RC522)模块模拟公交卡扣费代码实例
m0_57056767的博客
12-12 2060
使用Arduino对RFID(RC522)模块进行编程的实例，实现扣费和余额显示功能
i.MX283开发板SPI驱动——RC522
分享嵌入式Linux技术知识
03-13 1517
一、Linux下SPI驱动介绍 内核版本：2.6.35 Linux下SPI驱动和I2C驱动很类似，他们都是一种总线，且都不支持热拔插，因为一般情况下spi或者i2c设备都是直接焊接在板子上的，不像USB设备那样随时插拔，所以根据总线——设备——驱动模型，spi和i2c设备都可以通过xxx_board_info结构体进行注册，Linux下spi驱动的架构如下： spi核心层提供spi master...
智能锁SI522A+SI14T=13.56MHZ+触摸资料研发
Zhao13682455391的博客
02-28 318
触式读写器芯片，阅读器支持 ISO/IEC 14443A/MIFARE，JLIN用SMD方式下载，依次连接VCC,SWDIO,SWCLK,GND。Si522A 是一个高度集成的，工作在 13.56MHz 的非接。四根线，烧录器使用 JLINK,下载软件使用 Keil,测试。Si14T,14 通道自动灵敏度校准电容式触摸传感器,触摸感应结果可以通过 I2C 接口获取。触摸的强度可以被检测为三种（低，中，高，这三种。底座单片机选用 STM32FOO3OF4P6。分别对应的是触摸电容变化率小、中、大.
基于51，人体红外感应和RC522的门禁系统
weixin_30726161的博客
12-11 864
总结一下最近学的东西，这两天学的东西，rfid门卡系统终于弄出来来了，这个程序算现在写过的比较满意的程序，大家可以参考参考 主函数： #include<reg52.h> #include"mian.h" #include"rc522.h" #include"12864.h" //卡号为0扇区0块内容的前四字节为卡号，且此块内容不能改写 uchar statu...
stm32标准库移植到hal库
05-24
将STM32标准库移植到HAL库需要进行一些修改和适应。下面是一些步骤： 1. 修改头文件路径 首先，需要修改所有的头文件路径，以便它们可以正确地包含HAL库的头文件。例如，在标准库中，你可能会看到这样一个头文件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值