RC522 Access-card Arduino

最新推荐文章于 2024-03-13 17:45:00 发布
最新推荐文章于 2024-03-13 17:45:00 发布
阅读量1.2k 收藏 3
点赞数
分类专栏： Arduino C/C++ 文章标签： arduino

Connection

D 5 <————-> RST (It is possible for this pin to hang in the air)
D10 <————-> SDA (CS in RC522)
D11 <————-> MOSI
D12 <————-> MISO
D13 <————-> SCK
PS:The working voltage of RC522 is 3.3V

Library

include <SPI.h>
include <Servo.h>

//Arduino communicates via SPI protocol 
//The door will open by a servo

The Shortcoming

After watching the movie Dr. Strange yesterday, I’d like to tell you the shortcoming at the very beginning.

  1. It’s very inefficient. I use a 2k-mAh battery to test. And the result is it can only last for 12 hours or so.
  2. The code is very unfriendly and it is not modularized, next I’d like to change it into a library file.
  3. The judgement part is a little stubborn because there is too many if-else statements. It could be better if we use a database to manage.

Code

#include <SPI.h>
#include <Servo.h>

Servo myservo;  // create servo object to control a servo

#define uchar unsigned char
#define uint unsigned int

//data array maxium length
#define MAX_LEN 16
#define relay 7
/
//set the pin
/
const int chipSelectPin = 10;
const int NRSTPD = 5;

uchar Zhu = 0;
uchar Zhou = 0;
uchar Liao = 0;
uchar Chen = 0;
uchar Xing = 0;
uchar Yang = 0;
uchar Unknow_Guy = 0;

//MF522 command bits
#define PCD_IDLE 0x00 //NO action; cancel current commands
#define PCD_AUTHENT 0x0E //verify password key
#define PCD_RECEIVE 0x08 //receive data
#define PCD_TRANSMIT 0x04 //send data
#define PCD_TRANSCEIVE 0x0C //send and receive data
#define PCD_RESETPHASE 0x0F //reset
#define PCD_CALCCRC 0x03 //CRC check and caculation

//Mifare_One card command bits
#define PICC_REQIDL 0x26 //Search the cards that not into sleep mode in the antenna area 
#define PICC_REQALL 0x52 //Search all the cards in the antenna area
#define PICC_ANTICOLL 0x93 //prevent conflict
#define PICC_SElECTTAG 0x93 //select card
#define PICC_AUTHENT1A 0x60 //verify A password key
#define PICC_AUTHENT1B 0x61 //verify B password key
#define PICC_READ 0x30 //read 
#define PICC_WRITE 0xA0 //write
#define PICC_DECREMENT 0xC0 //deduct value
#define PICC_INCREMENT 0xC1 //charge up value
#define PICC_RESTORE 0xC2 //Restore data into buffer
#define PICC_TRANSFER 0xB0 //Save data into buffer
#define PICC_HALT 0x50 //sleep mode


//THe mistake code that return when communicate with MF522
#define MI_OK 0
#define MI_NOTAGERR 1
#define MI_ERR 2


//------------------MFRC522 register ---------------
//Page 0:Command and Status
#define Reserved00 0x00 
#define CommandReg 0x01 
#define CommIEnReg 0x02 
#define DivlEnReg 0x03 
#define CommIrqReg 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 Reserved01 0x0F
//Page 1:Command 
#define Reserved10 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 Reserved11 0x1A
#define Reserved12 0x1B
#define MifareReg 0x1C
#define Reserved13 0x1D
#define Reserved14 0x1E
#define SerialSpeedReg 0x1F
//Page 2:CFG 
#define Reserved20 0x20 
#define CRCResultRegM 0x21
#define CRCResultRegL 0x22
#define Reserved21 0x23
#define ModWidthReg 0x24
#define Reserved22 0x25
#define RFCfgReg 0x26
#define GsNReg 0x27
#define CWGsPReg 0x28
#define ModGsPReg 0x29
#define TModeReg 0x2A
#define TPrescalerReg 0x2B
#define TReloadRegH 0x2C
#define TReloadRegL 0x2D
#define TCounterValueRegH 0x2E
#define TCounterValueRegL 0x2F
//Page 3:TestRegister 
#define Reserved30 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 Reserved31 0x3C 
#define Reserved32 0x3D 
#define Reserved33 0x3E 
#define Reserved34 0x3F
//-----------------------------------------------

//4 bytes Serial number of card, the 5 bytes is verfiy bytes
uchar serNum[5];


void setup() 
{ 
    Serial.begin(57600); 

    SPI.begin();

    pinMode(chipSelectPin,OUTPUT); // Set digital pin 10 as OUTPUT to connect it to the RFID /ENABLE pin 
    digitalWrite(chipSelectPin, LOW); // Activate the RFID reader
    pinMode(NRSTPD,OUTPUT); // Set digital pin 5 , Not Reset and Power-down
    pinMode(relay, OUTPUT);
    myservo.attach(9);
    MFRC522_Init(); 
}


void loop()
{

    uchar status;
    uchar str[MAX_LEN];

    digitalWrite(relay, LOW);
    myservo.write(0);
    // Search card, return card types
    status = MFRC522_Request(PICC_REQIDL, str); 
    if (status != MI_OK)
    {
        return;
    }


    // Show card type
    ShowCardType(str);

    //Prevent conflict, return the 4 bytes Serial number of the card
    status = MFRC522_Anticoll(str);

    // str[0..3]: serial number of the card
    // str[4]: XOR checksum of the SN.
    if (status == MI_OK)
    {
        Serial.print("The card's number is: ");
        memcpy(serNum, str, 5);
        ShowCardID(serNum);
//        Serial.println(rfid.selectTag(rfid.serNum));
        // Check people associated with card ID
        uchar* id = serNum;

        if( id[0]==0xAA && id[1]==0xAA && id[2]==0xAA && id[3]==0xAA ) {
            ++Zhu;
            Serial.print("Hello Mr.Zhu! Time:");
            Serial.println(Zhu);
            digitalWrite(relay, HIGH);
            myservo.write(180);
        } else if(id[0]==0xBB && id[1]==0xBB && id[2]==0xBB && id[3]==0xBB) {
            ++Yang;
            Serial.print("Hello Mr.Yang! Time");
            Serial.println(Yang);
            digitalWrite(relay, HIGH);
            myservo.write(180);
        } else if(id[0]==0xCC && id[1]==0xCC && id[2]==0xCC && id[3]==0xCC) {
            ++Chen;
            Serial.print("Hello Mr.Chen! Time");
            Serial.println(Chen);
            digitalWrite(relay, HIGH);
            myservo.write(180);
        } else if(id[0]==0xDD && id[1]==0xDD && id[2]==0xDD && id[3]==0xDD) {
            ++Xing;
            Serial.print("Hello Mr.Xing! Time");
            Serial.println(Xing);
            digitalWrite(relay, HIGH);
            myservo.write(180);
        } else if(id[0]==0xEE && id[1]==0xEE && id[2]==0xEE && id[3]==0xEE) {
            ++Liao;
            Serial.print("Hello Mr.Liao! Time");
            Serial.println(Liao);
            digitalWrite(relay, HIGH);
            myservo.write(180);
        }  else if(id[0]==0xFF && id[1]==0xFF && id[2]==0xFF && id[3]==0xFF) {
            ++Zhou;
            Serial.print("Hello Mr.Zhou! Time");
            Serial.println(Zhou);
            digitalWrite(relay, HIGH);
            myservo.write(180);
        }  else if(id[0]==0x00 && id[1]==0x00 && id[2]==0x00 && id[3]==0x00) {
            ++Zhu;
            Serial.print("Hello Mr.Zhou! Time");
            Serial.println(Zhou);
            digitalWrite(relay, HIGH);
            myservo.write(180);
        } else {
            ++Unknow_Guy;
            Serial.println("Hello Unknow Guy~");
            Serial.println(Unknow_Guy);
            digitalWrite(relay, LOW);
            myservo.write(0);
        }
    }


    MFRC522_Halt(); //command the card into sleep mode 

    delay(1000);
}

/*
 * Function：ShowCardID
 * Description：Show Card ID
 * Input parameter：ID string
 * Return：Null
 */
void ShowCardID(uchar *id)
{
    int IDlen=4;
    for(int i=0; i<IDlen; i++){
        Serial.print(0x0F & (id[i]>>4), HEX);
        Serial.print(0x0F & id[i],HEX);
    }
    Serial.println("");
}

/*
 * Function：ShowCardType
 * Description：Show Card type
 * Input parameter：Type string
 * Return：Null
 */
void ShowCardType(uchar* type)
{
    Serial.print("Card type: ");
    if(type[0]==0x04&&type[1]==0x00) 
        Serial.println("MFOne-S50");
    else if(type[0]==0x02&&type[1]==0x00)
        Serial.println("MFOne-S70");
    else if(type[0]==0x44&&type[1]==0x00)
        Serial.println("MF-UltraLight");
    else if(type[0]==0x08&&type[1]==0x00)
        Serial.println("MF-Pro");
    else if(type[0]==0x44&&type[1]==0x03)
        Serial.println("MF Desire");
    else
        Serial.println("Unknown");
}

/*
 * Function：Write_MFRC5200
 * Description：write a byte data into one register of MR RC522
 * Input parameter：addr--register address；val--the value that need to write in
 * Return：Null
 */
void Write_MFRC522(uchar addr, uchar val)
{
    digitalWrite(chipSelectPin, LOW);

    //address format：0XXXXXX0
    SPI.transfer((addr<<1)&0x7E); 
    SPI.transfer(val);

    digitalWrite(chipSelectPin, HIGH);
}


/*
 * Function：Read_MFRC522
 * Description：read a byte data into one register of MR RC522
 * Input parameter：addr--register address
 * Return：return the read value
 */
uchar Read_MFRC522(uchar addr)
{
    uchar val;

    digitalWrite(chipSelectPin, LOW);

    //address format：1XXXXXX0
    SPI.transfer(((addr<<1)&0x7E) | 0x80); 
    val =SPI.transfer(0x00);

    digitalWrite(chipSelectPin, HIGH);

    return val; 
}

/*
 * Function：SetBitMask
 * Description：set RC522 register bit
 * Input parameter：reg--register address;mask--value
 * Return：null
 */
void SetBitMask(uchar reg, uchar mask) 
{
    uchar tmp;
    tmp = Read_MFRC522(reg);
    Write_MFRC522(reg, tmp | mask); // set bit mask
}


/*
 * Function：ClearBitMask
 * Description：clear RC522 register bit
 * Input parameter：reg--register address;mask--value
 * Return：null
 */
void ClearBitMask(uchar reg, uchar mask) 
{
    uchar tmp;
    tmp = Read_MFRC522(reg);
    Write_MFRC522(reg, tmp & (~mask)); // clear bit mask
} 


/*
 * Function：AntennaOn
 * Description：Turn on antenna, every time turn on or shut down antenna need at least 1ms delay
 * Input parameter：null
 * Return：null
 */
void AntennaOn(void)
{
    uchar temp;

    temp = Read_MFRC522(TxControlReg);
    if (!(temp & 0x03))
    {
        SetBitMask(TxControlReg, 0x03);
    }
}


/*
 * Function：AntennaOff
 * Description：Turn off antenna, every time turn on or shut down antenna need at least 1ms delay
 * Input parameter：null
 * Return：null
 */
void AntennaOff(void)
{
    ClearBitMask(TxControlReg, 0x03);
}


/*
 * Function：ResetMFRC522
 * Description： reset RC522
 * Input parameter：null
 * Return：null
 */
void MFRC522_Reset(void)
{
    Write_MFRC522(CommandReg, PCD_RESETPHASE);
}


/*
 * Function：InitMFRC522
 * Description：initilize RC522
 * Input parameter：null
 * Return：null
 */
void MFRC522_Init(void)
{
    digitalWrite(NRSTPD,HIGH);

    MFRC522_Reset();

    //Timer: TPrescaler*TreloadVal/6.78MHz = 24ms
    Write_MFRC522(TModeReg, 0x8D); //Tauto=1; f(Timer) = 6.78MHz/TPreScaler
    Write_MFRC522(TPrescalerReg, 0x3E); //TModeReg[3..0] + TPrescalerReg
    Write_MFRC522(TReloadRegL, 30); 
    Write_MFRC522(TReloadRegH, 0);

    Write_MFRC522(TxAutoReg, 0x40); //100%ASK
    Write_MFRC522(ModeReg, 0x3D); //CRC initilizate value 0x6363 ???

    //ClearBitMask(Status2Reg, 0x08); //MFCrypto1On=0
    //Write_MFRC522(RxSelReg, 0x86); //RxWait = RxSelReg[5..0]
    //Write_MFRC522(RFCfgReg, 0x7F); //RxGain = 48dB

    AntennaOn(); //turn on antenna
}


/*
 * Function：MFRC522_Request
 * Description：Searching card, read card type
 * Input parameter：reqMode--search methods，
 * TagType--return card types
 * 0x4400 = Mifare_UltraLight
 * 0x0400 = Mifare_One(S50)
 * 0x0200 = Mifare_One(S70)
 * 0x0800 = Mifare_Pro(X)
 * 0x4403 = Mifare_DESFire
 * return：return MI_OK if successed
 */
uchar MFRC522_Request(uchar reqMode, uchar *TagType)
{
    uchar status; 
    uint backBits; //the data bits that received

    Write_MFRC522(BitFramingReg, 0x07); //TxLastBists = BitFramingReg[2..0] ???

    TagType[0] = reqMode;
    status = MFRC522_ToCard(PCD_TRANSCEIVE, TagType, 1, TagType, &backBits);

    if ((status != MI_OK) || (backBits != 0x10))
    { 
        status = MI_ERR;
    }

    return status;
}


/*
 * Function：MFRC522_ToCard
 * Description：communicate between RC522 and ISO14443
 * Input parameter：command--MF522 command bits
 * sendData--send data to card via rc522
 * sendLen--send data length 
 * backData--the return data from card
 * backLen--the length of return data
 * return：return MI_OK if successed
 */
uchar MFRC522_ToCard(uchar command, uchar *sendData, uchar sendLen, uchar *backData, uint *backLen)
{
    uchar status = MI_ERR;
    uchar irqEn = 0x00;
    uchar waitIRq = 0x00;
    uchar lastBits;
    uchar n;
    uint i;

    switch (command)
    {
        case PCD_AUTHENT: //verify card password
        {
            irqEn = 0x12;
            waitIRq = 0x10;
            break;
        }
        case PCD_TRANSCEIVE: //send data in the FIFO
        {
            irqEn = 0x77;
            waitIRq = 0x30;
            break;
        }
        default:
            break;
    }

    Write_MFRC522(CommIEnReg, irqEn|0x80); //Allow interruption
    ClearBitMask(CommIrqReg, 0x80); //Clear all the interrupt bits
    SetBitMask(FIFOLevelReg, 0x80); //FlushBuffer=1, FIFO initilizate

    Write_MFRC522(CommandReg, PCD_IDLE); //NO action;cancel current command ???

    //write data into FIFO
    for (i=0; i<sendLen; i++)
    { 
        Write_MFRC522(FIFODataReg, sendData[i]); 
    }

    //procceed it
    Write_MFRC522(CommandReg, command);
    if (command == PCD_TRANSCEIVE)
    { 
        SetBitMask(BitFramingReg, 0x80); //StartSend=1,transmission of data starts 
    } 

    //waite receive data is finished
    i = 2000; //i should adjust according the clock, the maxium the waiting time should be 25 ms???
    do 
    {
        //CommIrqReg[7..0]
        //Set1 TxIRq RxIRq IdleIRq HiAlerIRq LoAlertIRq ErrIRq TimerIRq
        n = Read_MFRC522(CommIrqReg);
        i--;
    }
    while ((i!=0) && !(n&0x01) && !(n&waitIRq));

    ClearBitMask(BitFramingReg, 0x80); //StartSend=0

    if (i != 0)
    { 
        if(!(Read_MFRC522(ErrorReg) & 0x1B)) //BufferOvfl Collerr CRCErr ProtecolErr
        {
            status = MI_OK;
            if (n & irqEn & 0x01)
            { 
                status = MI_NOTAGERR; //?? 
            }

            if (command == PCD_TRANSCEIVE)
            {
                n = Read_MFRC522(FIFOLevelReg);
                lastBits = Read_MFRC522(ControlReg) & 0x07;
                if (lastBits)
                { 
                    *backLen = (n-1)*8 + lastBits; 
                }
                else
                { 
                    *backLen = n*8; 
                }

                if (n == 0)
                { 
                    n = 1; 
                }
                if (n > MAX_LEN)
                { 
                    n = MAX_LEN; 
                }

                //read the data from FIFO
                for (i=0; i<n; i++)
                { 
                    backData[i] = Read_MFRC522(FIFODataReg); 
                }
            }
        }
        else
        { 
            status = MI_ERR; 
        }

    }

    //SetBitMask(ControlReg,0x80); //timer stops
    //Write_MFRC522(CommandReg, PCD_IDLE); 

    return status;
}


/*
 * Function：MFRC522_Anticoll
 * Description：Prevent conflict, read the card serial number 
 * Input parameter：serNum--return the 4 bytes card serial number, the 5th byte is recheck byte
 * return：return MI_OK if successed
 */
uchar MFRC522_Anticoll(uchar *serNum)
{
    uchar status;
    uchar i;
    uchar serNumCheck=0;
    uint unLen;

    //ClearBitMask(Status2Reg, 0x08); //strSensclear
    //ClearBitMask(CollReg,0x80); //ValuesAfterColl
    Write_MFRC522(BitFramingReg, 0x00); //TxLastBists = BitFramingReg[2..0]

    serNum[0] = PICC_ANTICOLL;
    serNum[1] = 0x20;
    status = MFRC522_ToCard(PCD_TRANSCEIVE, serNum, 2, serNum, &unLen);

    if (status == MI_OK)
    {
        //Verify card serial number
        for (i=0; i<4; i++)
        { 
            serNumCheck ^= serNum[i];
        }
        if (serNumCheck != serNum[i])
        { 
            status = MI_ERR; 
        }
    }

    //SetBitMask(CollReg, 0x80); //ValuesAfterColl=1

    return status;
} 


/*
 * Function：CalulateCRC
 * Description：Use MF522 to caculate CRC
 * Input parameter：pIndata--the CRC data need to be read，len--data length，pOutData-- the caculated result of CRC
 * return：Null
 */
void CalulateCRC(uchar *pIndata, uchar len, uchar *pOutData)
{
    uchar i, n;

    ClearBitMask(DivIrqReg, 0x04); //CRCIrq = 0
    SetBitMask(FIFOLevelReg, 0x80); //Clear FIFO pointer
    //Write_MFRC522(CommandReg, PCD_IDLE);

    //Write data into FIFO 
    for (i=0; i<len; i++)
    { 
        Write_MFRC522(FIFODataReg, *(pIndata+i)); 
    }
    Write_MFRC522(CommandReg, PCD_CALCCRC);

    //waite CRC caculation to finish
    i = 0xFF;
    do 
    {
        n = Read_MFRC522(DivIrqReg);
        i--;
    }
    while ((i!=0) && !(n&0x04)); //CRCIrq = 1

    //read CRC caculation result
    pOutData[0] = Read_MFRC522(CRCResultRegL);
    pOutData[1] = Read_MFRC522(CRCResultRegM);
}



/*
 * Function：MFRC522_Write
 * Description：write block data
 * Input parameters：blockAddr--block address;writeData--Write 16 bytes data into block
 * return：return MI_OK if successed
 */
uchar MFRC522_Write(uchar blockAddr, uchar *writeData)
{
    uchar status;
    uint recvBits;
    uchar i;
    uchar buff[18]; 

    buff[0] = PICC_WRITE;
    buff[1] = blockAddr;
    CalulateCRC(buff, 2, &buff[2]);
    status = MFRC522_ToCard(PCD_TRANSCEIVE, buff, 4, buff, &recvBits);

    if ((status != MI_OK) || (recvBits != 4) || ((buff[0] & 0x0F) != 0x0A))
    { 
        status = MI_ERR; 
    }

    if (status == MI_OK)
    {
        for (i=0; i<16; i++) //Write 16 bytes data into FIFO
        { 
            buff[i] = *(writeData+i); 
        }
        CalulateCRC(buff, 16, &buff[16]);
        status = MFRC522_ToCard(PCD_TRANSCEIVE, buff, 18, buff, &recvBits);

        if ((status != MI_OK) || (recvBits != 4) || ((buff[0] & 0x0F) != 0x0A))
        { 
            status = MI_ERR; 
        }
    }

    return status;
}


/*
 * Function：MFRC522_Halt
 * Description：Command the cards into sleep mode
 * Input parameters：null
 * return：null
 */
void MFRC522_Halt(void)
{
    uchar status;
    uint unLen;
    uchar buff[4]; 

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

    status = MFRC522_ToCard(PCD_TRANSCEIVE, buff, 4, buff,&unLen);
}

查看原文出处

雪地冰激凌
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用Arduino连接RFID模块RC522
06-01
NULL 博文链接：https://hzy3774.iteye.com/blog/2322511
rfid, 面向MFRC522的Arduino RFID库.zip
09-18
rfid, 面向MFRC522的Arduino RFID库 MFRC522 面向MFRC522和其他 RFID RC522模块的Arduino库。使用基于串口接口的阅读器，在你的Arduino上读取和写入不同类型的射频识别卡，这些读卡器通过串口接口接口连接。插件开发所有者
arduino rc522模块使用
economics3的博客
01-14 2446
一个ic的存储结构就是上面的样子，而我们在读取ic卡会选取一个扇区，这个扇区中设置的密钥可以用于ic卡的验证，而ic卡总共有16个，这样可以为一个IC卡提供多个功能，实现一卡多用。SPI的连线是根据ESP32引脚功能来设置的，但是有文章说可以通过SPI来自己自定义设置（库作者没有提供定义的功能），读者可以自行设置。如果这个扇区没有经过密钥的解锁是没办法读取的，有兴趣的可以了解一下IC卡的破译（比如说水卡，一些门禁的验证）。大致上面的函数就能完成我们的基本的需求了，一些功能的完成，使用这三个函数就足够了。
arduino读写MFRC522射频RRFID模块
河西~石头
08-31 4491
常见的射频模块读写操作，FRID在arduino中的使用。
arduino+rc522读写卡
11-15
标题中的“arduino+rc522读写卡&rdquo;指的是使用Arduino微控制器平台配合RC522模块进行RFID（无线频率识别）的操作。RC522是基于MFRC522芯片的一种常用的RFID模块，它能工作在13.56MHz频率范围内，常用于非接触式IC卡的...
MFRC522-UART-Arduino-master.zip
10-17
MFRC522-UART-Arduino-master.zip这个压缩包文件包含了使用MFRC522芯片与Arduino进行UART通信的相关资源。MFRC522是一款由NXP Semiconductors制造的RFID（无线频率识别）芯片，专门用于实现MIFARE协议的读写模块。在...
基于Arduino的RC522读卡实验.pdf
11-16
"基于 Arduino 的 RC522 读卡实验" 本实验旨在使用 Arduino Nano 开发板和 RC522 模块实现 RFID 读卡功能。实验中使用的硬件包括 Windows PC、Arduino Nano 开发板、RC522 模块、面包板、导线和 S50 卡。软件方面，...
RFID-RC522:Arduino的RFID-RC522
04-30
RFID RC522 连接 引脚布局应如下所示： 射频识别 Arduino的 3.3伏 3.3伏 RST 9 地线 地线 味噌 12 摩西 11 SCK 13 SDA 10 问卷 -- IRQ未连接 安装RFID库 cd ~/Documents/Arduino/libraries git clone ...
RFID库--Arduino
08-14
**RFID库——Arduino** 在Arduino开发中，RFID（Radio Frequency Identification）技术是一种常见的无线通信技术，用于识别特定目标并读取或写入数据，而无需物理接触。这个库是专门为Arduino设计的，用于与RFID...
基于PCSC的Desfire4K卡的操作源代码
12-06
基于PCSC的Desfire4K卡的操作源代码VC++，在ACS ACR1251U读卡器测试通过 详见http://happyboy200032.blog.163.com
RC522刷卡电路设计及程序
最新发布
STM89C56的博客
03-13 2764
RC522刷卡电路设计与程序设计
实现一个简单C#DES加密类
jjyjjyjjy的专栏
03-28 1678
using System;using System.Collections.Generic;using System.Text;using System.Security.Cryptography;using System.IO;namespace MyWinFormApp{    public class DEScrypt    {        #region "Private Field
NFC读卡器工具
weimou66
11-20 1074
测试过了，完美支持我的读卡器ACR122U NFC 非接触式IC卡读写器USB，我的MiFare Ultralight卡片。 The release 1.20 of SpringCard PC/SC SDK is now available in the Download section of the website (direct link to latest version :http:...
desfire卡写文件操作
zsmj0513的专栏
01-23 3050
最近对desfire卡进行操作： 芯片： MF3 IC D40 Contactless  Multi-Application IC with DES and 3DES Security   参考网上NXP的资料 在对 市民卡05文件进行写文件操作的时候 出现写失败的情况： 写文件命令： 组成写命令：3D 05 00 00 00 16 00 00 +要写入的文件数据（0x16个字节） ...
Arduino教程 RFID-RC522读IC卡门禁原理及破解防御
weixin_30629653的博客
06-20 7649
【文章特色：1、提出IC卡破解原理和简单有效的防御方法2、网上其他文章对于硬件如何接线说得模糊不清】 1、序言 先说下简单门禁系统的原理： (1)IC卡激活：门禁卡管理员将卡片放到读卡器、这时软件读取到IC卡的UID序列号信息(相当于身份证号码)，将这个UID录入数据库激活IC卡。 (2)刷卡：刷卡时读卡器读取到UID，查询数据库，如果数据库中存在这个UID则表示有效用户,继而控制...
MF-RC522 RFID 在Arduino中的读取
张国策de电子博客
04-19 1万+
最重要的是通信方式和连接方式。Arduino板子与RC522之间是SPI通信，Arduino工作在主模式下， RC522工作在从模式下。连接方式如下：    Arduino                                       RC522 (工作电压3.3V) D5                                RST    (这个脚不接貌似
Arduino入门教程—RFID模块的使用（MF RC522）
热门推荐
qq5132834的专栏
05-20 5万+
http://www.yfrobot.com/forum.php?mod=viewthread&tid=2375&highlight=rfid RFID模块的使用 RFID简介：射频识别即RFID（Radio Frequency IDentification）技术，又称无线射频识别，是一种通信技术，可通过无线电讯号识别特定目标并读写相关数据，而无需识别系统与特定目标之间建立机械或光
rc522 esp8266 arduino
12-18
RC522是一款基于13.56MHz射频技术的RFID读写模块，具有低功耗、高灵敏度和稳定性的特点。它可以与ESP8266和Arduino等微控制器进行通信。ESP8266是一款热门的Wi-Fi模块，其集成了处理器、Wi-Fi模块和存储器等功能单元，具有强大的无线通信能力。Arduino是一款开源硬件平台，其提供了简单易用的软硬件接口，便于开发者构建各种物联网项目。 通过将RC522与ESP8266或Arduino连接，我们可以实现RFID技术在物联网等领域的应用。首先，RC522读取RFID卡的标签信息，包括卡号等，然后将这些信息传输给ESP8266或Arduino进行处理。ESP8266或Arduino可以根据这些信息来控制其他设备或执行各种操作。例如，在门禁系统中，当有效的RFID卡被读取后，ESP8266或Arduino可以发送信号给门禁控制器，打开门锁。在仓储管理中，RC522读取RFID标签上的物品信息，然后ESP8266或Arduino将这些信息发送给服务器进行存储，方便查询和管理。此外，还可以将RC522与其它传感器模块结合，实现更多功能，例如温湿度感知、光线感应等。 在连接RC522与ESP8266或Arduino时，我们需要注意引脚的连接，以及相应的引脚配置和程序编写。一般来说，RC522模块的VCC和GND引脚分别连接到ESP8266或Arduino的3.3V和GND引脚，SDA引脚连接到GPIO引脚，SCK、MISO和MOSI引脚连接到SPI通信引脚。然后，在程序中使用相应的库和函数，进行RFID标签的读取和处理。 综上所述，通过RC522与ESP8266或Arduino的结合，可以实现基于RFID技术的物联网应用，丰富了物联网领域的技术应用和发展可能性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值