Rfid Rc522 Arduino Uno Code | Description

STEP 4

OUTPUT

Upload the sketch and open the Serial Monitor. As soon as you bring the tag closer to the module, you’ll probably get something like the figure given below. Do not move the tag until all the information is displayed.

In this example project , it displays all the useful information about the tag including tag’s Unique ID (UID), the memory size and the whole 1K memory.The 1K memory of the Tag is organized in 16 sectors (from 0 to 15)Each sector is further devided in to 4 blocks (block 0 to 3).Each block can store 16 bytes of data (from 0 to 15).The Block 3 of each sector is called Sector Trailer and contains information called Access Bits to grant read and write access to remaining blocks in a sector. That means only the bottom 3 blocks (block 0, 1 & 2) of each sector are actually available for data storage, meaning we have 48 bytes per 64 byte sector available for our own use.Also The Block 0 of sector 0 is known as Manufacturer Block/Manufacturer Data contains the IC manufacturer data, and the Unique IDentifier (UID)

Các linh kiện cần thiết cho dự án

TÊN LINH KIỆN	SỐ LƯỢNG	NƠI BÁN
Arduino Uno R3	Shopee | Cytron
RFID RC522	Shopee | Cytron
Dây cắm (Đực – Cái)	10 – 20	Shopee | Cytron

Description

RFID means radio-frequency identification. RFID uses electromagnetic fields to transfer data over short distances. RFID is useful to identify people, to make transactions, etc…

You can use an RFID system to open a door. For example, only the person with the right information on his card is allowed to enter. An RFID system uses:

• tags attached to the object to be identified, in this example we have a keychain and an electromagnetic card. Each tag has his own identification (UID).

• two-way radio transmitter-receiver, the reader, that send a signal to the tag and read its response.

Pin wiring

Pin	Wiring to Arduino Uno
SDA	Digital 10
SCK	Digital 13
MOSI	Digital 11
MISO	Digital 12
IRQ	unconnected
GND	GND
RST	Digital 9
3.3V	3.3V

Caution: You must power this device to 3.3V!

Code: Đọc thẻ RFID

Sau khi bạn đã cài đặt thư viện thành công, vào phần Ví dụ và chọn MFRC522 > DumpInfo.

Đoạn code này dùng để đọc và hiển thị thông tin thẻ RFID lên cổng Serial.

Định nghĩa chân kết nối RST_PIN là chân số 5 trên Arduino.

Tiếp hành nạp Code vào Arduino Uno, đưa thẻ đến module RFID Arduino, bạn sẽ nhận được giá trị như sau. Lưu ý, không di chuyển thẻ cho đến khi tất cả các thông tin được hiển thị.

SAMPLE CODE:

The sample code is available from the git link here

Feel free to reach out to us at [email protected] for any product or tech related enquiries.

Mạch RFID RC522 NFC 13.56Mhz

13.56Mhz RC522 RFID Card Reader Module

Mã sản phẩm: NOTK

Sản phẩm hiện đang còn hàng.

Xem chi nhánh còn hàng

Mạch RFID RC522 NFC 13.56Mhz Nguồn: 3.3VDC, 13 – 26mA, Tần số sóng mang: 13.56MHz, Giao tiếp: SPI

• Cộng thêm 2 điểm tích lũy

• TP.HCM: Miễn phí vận chuyển đơn hàng từ 300k

  Tỉnh thành khác: Miễn phí vận chuyển đơn hàng từ 500k

  Xem thêm các khuyến mãi vận chuyển khác.

Cài đặt thư viện MFRC522

Mở Arduino IDE trên máy tính của bạn. Trong menu chính của Arduino IDE, chọn “Sketch” -> “Include Library” -> “Manage Libraries…”.

Một cửa sổ “Library Manager” sẽ hiển thị. Trong ô tìm kiếm, gõ “MFRC522” và nhấn Enter.

Thư viện “MFRC522” sẽ xuất hiện trong kết quả tìm kiếm. Nhấn vào nút “Install” bên cạnh thư viện để tiến hành cài đặt.

Sơ đồ chân Module RFID RC522

• SDA (Serial Data): Dùng để truyền và nhận dữ liệu giữa module RFID RC522 Arduino.

• SCK (Serial Clock): Dùng để đồng bộ hóa truyền thông SPI giữa module RFID RC522 và Arduino.

• MOSI (Master Output Slave Input): Dùng để truyền dữ liệu từ Arduino tới module RFID RC522.

• MISO (Master Input Slave Output): Chân đầu vào của Arduino nối với chân MISO trên module RFID RC522. Dùng để nhận dữ liệu từ module RFID RC522 về Arduino qua giao thức SPI.

• IRQ (Interrupt Request): Chân ngắt không được sử dụng trong một số ứng dụng của module RFID RC522. Nếu sử dụng, chân này được sử dụng để xác định xem module RFID RC522 có sự kiện cần xử lý hay không.

• GND (Ground): Chân đất kết nối với chân GND trên Arduino.

• RST (Reset): Chân đặt lại (reset) module RFID RC522. Khi chân này được kích hoạt, module sẽ được đặt lại về trạng thái ban đầu.

• 3.3V: Nguồn cấp 3.3V cho module.

RFID là gì? Nguyên lý hoạt động của Module RFID RC522

RFID là viết tắt của “Radio Frequency Identification”, có nghĩa là nhận dạng bằng tần số radio. Đây là một công nghệ sử dụng sóng radio để truyền và nhận dạng thông tin từ một thẻ hoặc một thiết bị RFID. Hệ thống RFID bao gồm ít nhất hai thành phần chính: một thẻ RFID (hay còn gọi là tag RFID) và một đầu đọc RFID (hay còn gọi là reader RFID).

Thẻ RFID thường được gắn vật lên vật thể, nó chứa một anten để thu phát sóng radio và một chip chứa thông tin cần được nhận dạng. Đầu đọc RFID sử dụng sóng radio để truyền đi và nhận lại thông tin từ thẻ RFID. Khi thẻ RFID được đặt trong phạm vi hoạt động của đầu đọc RFID, thông tin từ thẻ sẽ được truyền đến đầu đọc RFID để xử lý và xác định thông tin nhận dạng.

Bố cục bộ nhớ MIFARE Classic 1K

MIFARE Classic 1K là một loại thẻ RFID được sử dụng phổ biến trong các ứng dụng thẻ thông minh và hệ thống điều khiển truy cập. Nó có dung lượng bộ nhớ 1 kilobyte (1024 bytes) và được chia thành các khối (blocks) và phân đoạn (sectors).

Dung lượng bộ nhớ: MIFARE Classic 1K có tổng cộng 16 phân đoạn, mỗi phân đoạn chứa 4 khối, mỗi khối chứa 16 byte. Do đó, tổng dung lượng bộ nhớ là 16 phân đoạn x 4 khối x 16 byte = 1024 byte.

Phân đoạn (Sectors): Mỗi phân đoạn chứa 4 khối dữ liệu và một khối chứa thông tin định danh (trailer block). Số thứ tự của phân đoạn được đánh từ 0 đến 15.

Khối (Blocks): Mỗi khối có kích thước 16 byte. Trong mỗi phân đoạn, có 3 khối dữ liệu và 1 khối trailer block. Khối trailer chứa thông tin định danh, quản lý quyền truy cập và khóa.

Truy cập và bảo vệ dữ liệu: Mỗi khối có thể được bảo vệ bằng một khóa (key). Chỉ những người có khóa chính (key A hoặc key B) mới có thể truy cập và ghi dữ liệu vào khối. Quyền truy cập và quản lý khóa được quản lý thông qua khối trailer.

Phân chia quyền truy cập: Mỗi khối có thể được chia thành 2 phần với các quyền truy cập khác nhau, bao gồm quyền đọc, ghi và xóa.

Thông tin định danh (UID): Mỗi thẻ MIFARE Classic 1K có một số ID duy nhất (UID) 4 byte được sử dụng để xác định thẻ.

Code: Đọc và ghi dữ liệu từ thẻ RFID sử dụng module RC522

Đoạn code bên dưới có chức năng đọc và ghi dữ liệu từ module RFID RC522 bằng Arduino Uno.

#include

//include the SPI bus library #include

//include the RFID reader library #define SS_PIN 10 //slave select pin #define RST_PIN 5 //reset pin MFRC522 mfrc522(SS_PIN, RST_PIN); // instatiate a MFRC522 reader object. MFRC522::MIFARE_Key key; //create a MIFARE_Key struct named ‘key’, which will hold the card information //this is the block number we will write into and then read. int block=2; byte blockcontent[16] = {“Last-Minute-Engg”}; //an array with 16 bytes to be written into one of the 64 card blocks is defined //byte blockcontent[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //all zeros. This can be used to delete a block. //This array is used for reading out a block. byte readbackblock[18]; void setup() { Serial.begin(9600); // Initialize serial communications with the PC SPI.begin(); // Init SPI bus mfrc522.PCD_Init(); // Init MFRC522 card (in case you wonder what PCD means: proximity coupling device) Serial.println(“Scan a MIFARE Classic card”); // Prepare the security key for the read and write functions. for (byte i = 0; i < 6; i++) { key.keyByte[i] = 0xFF; //keyByte is defined in the “MIFARE_Key” ‘struct’ definition in the .h file of the library } } void loop() { // Look for new cards if ( ! mfrc522.PICC_IsNewCardPresent()) { return; } // Select one of the cards if ( ! mfrc522.PICC_ReadCardSerial()) { return; } Serial.println(“card selected”); //the blockcontent array is written into the card block writeBlock(block, blockcontent); //read the block back readBlock(block, readbackblock); //uncomment below line if you want to see the entire 1k memory with the block written into it. //mfrc522.PICC_DumpToSerial(&(mfrc522.uid)); //print the block contents Serial.print(“read block: “); for (int j=0 ; j<16 ; j++) { Serial.write (readbackblock[j]); } Serial.println(“”); } //Write specific block int writeBlock(int blockNumber, byte arrayAddress[]) { //this makes sure that we only write into data blocks. Every 4th block is a trailer block for the access/security info. int largestModulo4Number=blockNumber/4*4; int trailerBlock=largestModulo4Number+3;//determine trailer block for the sector if (blockNumber > 2 && (blockNumber+1)%4 == 0){Serial.print(blockNumber);Serial.println(” is a trailer block:”);return 2;} Serial.print(blockNumber); Serial.println(” is a data block:”); //authentication of the desired block for access byte status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid)); if (status != MFRC522::STATUS_OK) { Serial.print(“PCD_Authenticate() failed: “); Serial.println(mfrc522.GetStatusCodeName(status)); return 3;//return “3” as error message } //writing the block status = mfrc522.MIFARE_Write(blockNumber, arrayAddress, 16); //status = mfrc522.MIFARE_Write(9, value1Block, 16); if (status != MFRC522::STATUS_OK) { Serial.print(“MIFARE_Write() failed: “); Serial.println(mfrc522.GetStatusCodeName(status)); return 4;//return “4” as error message } Serial.println(“block was written”); } //Read specific block int readBlock(int blockNumber, byte arrayAddress[]) { int largestModulo4Number=blockNumber/4*4; int trailerBlock=largestModulo4Number+3;//determine trailer block for the sector //authentication of the desired block for access byte status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid)); if (status != MFRC522::STATUS_OK) { Serial.print(“PCD_Authenticate() failed (read): “); Serial.println(mfrc522.GetStatusCodeName(status)); return 3;//return “3” as error message } //reading a block byte buffersize = 18;//we need to define a variable with the read buffer size, since the MIFARE_Read method below needs a pointer to the variable that contains the size… status = mfrc522.MIFARE_Read(blockNumber, arrayAddress, &buffersize);//&buffersize is a pointer to the buffersize variable; MIFARE_Read requires a pointer instead of just a number if (status != MFRC522::STATUS_OK) { Serial.print(“MIFARE_read() failed: “); Serial.println(mfrc522.GetStatusCodeName(status)); return 4;//return “4” as error message } Serial.println(“block was read”); }

Sau khi nạp code và tiến hành quét thẻ thì thông tin hiển thị sẽ như thế này.

Giải thích Code

#include

//include the SPI bus library #include

//include the RFID reader library

Khai báo và

include

các thư viện cần thiết để sử dụng module RFID Arduino.

#define SS_PIN 10 //slave select pin #define RST_PIN 5 //reset pin

Định nghĩa các chân kết nối với module RFID RC522 trên Arduino Uno.

MFRC522 mfrc522(SS_PIN, RST_PIN); // instatiate a MFRC522 reader object. MFRC522::MIFARE_Key key; //create a MIFARE_Key struct named ‘key’, which will hold the card information

Khởi tạo đối tượng mfrc522 để sử dụng các phương thức của module RFID.

//this is the block number we will write into and then read. int block=2; byte blockcontent[16] = {“Last-Minute-Engg”}; //an array with 16 bytes to be written into one of the 64 card blocks is defined //byte blockcontent[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //all zeros. This can be used to delete a block. //This array is used for reading out a block. byte readbackblock[18];

Khai báo một cấu trúc MIFARE_Key để lưu trữ thông tin định danh của thẻ.

void setup() { Serial.begin(9600); // Initialize serial communications with the PC SPI.begin(); // Init SPI bus mfrc522.PCD_Init(); // Init MFRC522 card (in case you wonder what PCD means: proximity coupling device) Serial.println(“Scan a MIFARE Classic card”); // Prepare the security key for the read and write functions. for (byte i = 0; i < 6; i++) { key.keyByte[i] = 0xFF; //keyByte is defined in the “MIFARE_Key” ‘struct’ definition in the .h file of the library } }

Hàm

setup()

được gọi một lần khi Arduino khởi động. Nó khởi tạo các cài đặt ban đầu cho module RFID RC522 và khóa truy cập (key) cho việc đọc và ghi dữ liệu.

void loop() { // Look for new cards if ( ! mfrc522.PICC_IsNewCardPresent()) { return; } // Select one of the cards if ( ! mfrc522.PICC_ReadCardSerial()) { return; } Serial.println(“card selected”); //the blockcontent array is written into the card block writeBlock(block, blockcontent); //read the block back readBlock(block, readbackblock); //uncomment below line if you want to see the entire 1k memory with the block written into it. //mfrc522.PICC_DumpToSerial(&(mfrc522.uid)); //print the block contents Serial.print(“read block: “); for (int j=0 ; j<16 ; j++) { Serial.write (readbackblock[j]); } Serial.println(“”); }

Hàm

loop()

được lặp lại liên tục sau khi khởi động. Nó kiểm tra xem có thẻ RFID Arduino nằm trong phạm vi hoạt động của module hay không. Nếu có, nó tiến hành ghi dữ liệu vào khối và đọc lại khối đó. Sau đó, nội dung của khối được in ra trên cổng Serial.

//Write specific block int writeBlock(int blockNumber, byte arrayAddress[]) { //this makes sure that we only write into data blocks. Every 4th block is a trailer block for the access/security info. int largestModulo4Number=blockNumber/4*4; int trailerBlock=largestModulo4Number+3;//determine trailer block for the sector if (blockNumber > 2 && (blockNumber+1)%4 == 0){Serial.print(blockNumber);Serial.println(” is a trailer block:”);return 2;} Serial.print(blockNumber); Serial.println(” is a data block:”); //authentication of the desired block for access byte status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid)); if (status != MFRC522::STATUS_OK) { Serial.print(“PCD_Authenticate() failed: “); Serial.println(mfrc522.GetStatusCodeName(status)); return 3;//return “3” as error message } //writing the block status = mfrc522.MIFARE_Write(blockNumber, arrayAddress, 16); //status = mfrc522.MIFARE_Write(9, value1Block, 16); if (status != MFRC522::STATUS_OK) { Serial.print(“MIFARE_Write() failed: “); Serial.println(mfrc522.GetStatusCodeName(status)); return 4;//return “4” as error message } Serial.println(“block was written”); }

Hàm

writeBlock()

: Hàm này được sử dụng để ghi dữ liệu vào một khối cụ thể trên thẻ RFID. Trước khi ghi dữ liệu, hàm xác thực quyền truy cập vào khối và sau đó thực hiện việc ghi dữ liệu vào khối đó.

//Read specific block int readBlock(int blockNumber, byte arrayAddress[]) { int largestModulo4Number=blockNumber/4*4; int trailerBlock=largestModulo4Number+3;//determine trailer block for the sector //authentication of the desired block for access byte status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid)); if (status != MFRC522::STATUS_OK) { Serial.print(“PCD_Authenticate() failed (read): “); Serial.println(mfrc522.GetStatusCodeName(status)); return 3;//return “3” as error message } //reading a block byte buffersize = 18;//we need to define a variable with the read buffer size, since the MIFARE_Read method below needs a pointer to the variable that contains the size… status = mfrc522.MIFARE_Read(blockNumber, arrayAddress, &buffersize);//&buffersize is a pointer to the buffersize variable; MIFARE_Read requires a pointer instead of just a number if (status != MFRC522::STATUS_OK) { Serial.print(“MIFARE_read() failed: “); Serial.println(mfrc522.GetStatusCodeName(status)); return 4;//return “4” as error message } Serial.println(“block was read”); }

Hàm

readBlock()

: Hàm này được sử dụng để đọc dữ liệu từ một khối cụ thể trên thẻ RFID. Trước khi đọc dữ liệu, hàm xác thực quyền truy cập vào khối và sau đó thực hiện việc đọc dữ liệu từ khối đó.

This blog post shows a simple example on how to use the MFRC522 RFID reader. I’ll do a quick overview of the specifications and demonstrate a project example using an Arduino.

Tổng quan về phần cứng

Module RFID RC522 là một module sử dụng công nghệ RFID để đọc và ghi thông tin từ các thẻ RFID. Nó được sử dụng phổ biến trong các dự án Arduino và các ứng dụng liên quan đến nhận dạng và theo dõi.

Module RFID Arduino bao gồm một chip đọc RFID MFRC522 và các thành phần khác như anten và các linh kiện điện tử. Chip MFRC522 có khả năng đọc và ghi dữ liệu từ các thẻ RFID tiêu chuẩn, bao gồm các loại thẻ MIFARE và các loại thẻ tương thích.

Module RFID RC522 kết nối với Arduino thông qua giao tiếp SPI (Serial Peripheral Interface) hoặc I2C và UART.

Để sử dụng module RFID RC522, cần có thư viện hỗ trợ cho Arduino như thư viện MFRC522, giúp dễ dàng giao tiếp và điều khiển module. Thông qua thư viện này, bạn có thể đọc thông tin từ thẻ RFID, xác minh chúng và thực hiện các hoạt động như đọc mã số, ghi dữ liệu, kiểm tra trạng thái và điều khiển anten.

Thông số kỹ thuật

Frequency Range	13.56 MHz ISM Band
Host Interface	SPI / I2C / UART
Operating Supply Voltage	2.5 V to 3.3 V
Max. Operating Current	13-26mA
Min. Current(Power down)	10µA
Logic Inputs	5V Tolerant
Read Range	5 cm

Demonstration

Now, upload the code to your Arduino and open the serial monitor.

Approximate the card you’ve chosen to give access and you’ll see:

If you approximate another tag with another UID, the denial message will show up:

I hope you found this tutorial useful.

Share this post with a friend that also likes electronics!

You can contact me by leaving a comment. If you like this post probably you might like my next ones, so please support me by subscribing my blog.

Thanks for reading,

-Rui Santos

RC522 là Module RFID đa giao tiếp với Arduino và Vi điều khiển. RC522 còn gọi là MFRC-522 sản xuất bởi hãng vi điều khiển bán dẫn NFX. Module cho phép các nhà phát triển giao tiếp với các vi điều khiển dựa trên giao thức SPI, I2C và UART.

Module RC522 hoạt động ở tần số 13.56 MHz và đọc và ghi thẻ UID / RFID. Các thẻ RFID giao tiếp được với module ở khoảng cách ngắn với tần số vô tuyến nhờ cảm ứng điện từ lẫn nhau.

Trong các thiết bị bảo mật và thương mại, module rất phù hợp vì có thể phát hiện được các trạng thái và thông tin của thẻ RFID.

Trong module này, chỉ có hai loại chân. Vì vậy, đầu tiên là các chân nguồn và thứ hai là các chân giao tiếp. Do đó, thiết bị có thể có chip vi điều khiển nhưng nó chỉ hoạt động với thẻ RFID. Bộ vi điều khiển tích hợp sẽ không làm cho module trở thành một linh kiện độc lập.

Chân	Mô tả chi tiết
Chân 1	VCC	Chân nguồn VCC. Trong một số phiên bản của RC522, chân này được ký hiệu là 3V3 thay vì VCC.
Chân 2	RST	Là chân reset được sử dụng để đặt lại giá trị trong trường hợp xảy ra lỗi khi thiết bị không bất kỳ phản hồi.
Chân 3	Ground	Chân nối đất giúp tạo mass chung với các thiết bị bên ngoài (ví dụ bộ nguồn, bi điều khiển hoặc arduino).

Chân	Mô tả chi tiết
Chân 4	IRQ	Linh kiện có thể chuyển sang chế độ ngủ để tiết kiệm điện năng và chân IRQ sẽ khởi động lại nó
Chân 5	MISO	SCL TX	Chân này kết nối với Arduino / Vi điều khiển để giao tiếp SPI. Truyền dữ liệu từ module sang Arduino. Chân MISO cũng có thể sử dụng cho các chức năng khác thay vì SPI. Cũng có thể giao tiếp I2C và UART Serial để giao tiếp dữ liệu với module.
Chân 6	MOSI	MOSI là chân đầu vào dữ liệu module RFID khi giao tiếp SPI
Chân 7	SCK	Các chân SCK gửi xung clock khi giao tiếp SPI.
Chân 8	SS	SDA RX	Chân SS là chân kích hoạt chip giao tiếp SPI. Nhận tín hiệu khi Master (Arduino) giao tiếp SPI. Chân SS của RFID có thể được sử dụng như một chân thứ hai (SDA) của giao tiếp I2C. Cũng là chân nhận dữ liệu trong quá trình giao tiếp UART.

Việc sử dụng RC 522 vừa đơn giản vừa phức tạp. Ngay cả thư viện hỗ trợ của nó cũng có quá nhiều phức tạp để sử dụng. Trước tiên, hãy hiểu rằng các ví dụ và thư viện hỗ trợ đều cho giao thức SPI nhưng cùng một thư viện có thể sử dụng được cho các giao tiếp UART và I2C Serial khác.

Để sử dụng RC522 với Arduino, bảng mạch phổ biến nhất được cho ở bên dưới

Hầu hết các bo mạch đều có các chân cụ thể để giao tiếp SPI. Trong các chân SPI, chỉ có chân SS là có thể thay đổi được, các chân khác phải tùy theo thiết bị. Trong sơ đồ mạch trên, RFID kết nối với Arduino UNO thông qua các chân SPI cụ thể của nó.

Sau khi thiết kế mạch, cần khai báo hai thư viện sau:

#include

#include

Thư viện MFRC522 giúp giải mã và mã hóa dữ liệu từ module RFID và SPI.h sẽ giúp thiết lập giao tiếp SPI. Hai thư viện này phụ thuộc vào nhau. Sau khi khởi tạo các thư viện, thì phải khai báo chân reset và chọn SS thông qua lệnh sau:

MFRC522 mfrc522 (SS_PIN, RST_PIN);

Thay đổi SS_PIN thành chân điều khiển SS của RFID tương ứng trên arduino và RST_PIN thành chân điều khiển chân reset của RFID. Bây giờ phải khai báo phần khởi tạo giao tiếp SPI và phần khởi tạo module cần được thực hiện qua 2 lệnh sau.

SPI.begin (); mfrc522.PCD_Init ();

Khi viết 2 lệnh này việc khởi tạo giao tiếp các module sẽ hoàn tất nhưng phần trên hơi phức tạp. Thư viện RC522 cung cấp nhiều lệnh nhưng để sử dụng các lệnh đó thì phải hiểu một số chức năng.

Trong RC522, thẻ RFID có thể đọc được khi có thẻ đặt gần module. Khi một thẻ được đọc thì module sẽ lưu mã trừ khi nó bị sai (có mã “FFFFFFFFFFFFh”). Lệnh sau sẽ tạo mã mặc định cho module.

MFRC522::MIFARE_Key key; for(byte i = 0; i <6; i ++) key.keyByte [i] = 0xFF;

MIFARE_Key sẽ tự động ghi vào module và vòng lặp sẽ giúp lưu mã.

Khi các giá trị mặc định của thẻ được thiết lập, các lệnh sau sẽ cho phép phát hiện thẻ mới

mfrc522.PICC_IsNewCardPresent () mfrc522.PICC_ReadCardSerial ()

Lệnh đầu tiên là để phát hiện thẻ và lệnh tiếp theo là đọc mã thẻ. Đôi khi thẻ có thể ở gần module nhưng nó không có dữ liệu mã. Do đó, lệnh thứ hai ReadCardSerial sẽ giúp phát hiện điều đó. Sau đó, sử dụng lệnh sau để xem dữ liệu để có thể giải mã:

mfrc522.PICC_DumpDetailsToSerial (& (mfrc522.uid)); mfrc522.PICC_DumpToSerial (& (mfrc522.uid));

Sử dụng lệnh đầu tiên cho hệ thập phân và lệnh hai cho hệ HEX. Giúp lưu trữ và đọc mã dữ liệu. Luôn nhớ rằng thiết bị có thể đọc và xuất / giải mã dữ liệu của 1 thẻ tại một thời điểm. Do đó, trong quá trình xử lý, thiết bị sẽ không thể đọc thẻ mới.

Có khả năng xác định thẻ bị lỗi hoặc không thể đọc được và sau đó chương trình có thể thông báo để xử lý.

Trạng thái lỗi có thể không đáng tin cậy nhưng trong một số trường hợp, nó cho phép các lập trình viên chạy các lệnh cụ thể để xóa lỗi. Vì vậy, lệnh sau sẽ giúp đọc trạng thái:

MFRC522::StatusCode status //To read the status mfrc522.PCD_Authenticate //To get the authentication mfrc522.MIFARE_Read //To read the card

Các lệnh đầu tiên chỉ đọc các ký hiệu, các lệnh còn sẽ đọc dữ liệu trạng thái.

Khi thẻ đọc các lệnh, nó sẽ không bao giờ dừng lại cho đến khi có lệnh dừng được gửi đi. Để dừng mã hóa tín hiệu, các lệnh cần được gửi từ bộ vi điều khiển. Do đó, các lệnh dừng cho cả hai chức năng đọc và mã hóa sẽ là:

mfrc522.PICC_HaltA (); // Stop reading mfrc522.PCD_StopCrypto1 (); // Stop encryption on PCD

Các lệnh trên chỉ là các lệnh đọc đơn giản, hiện nay có hàng loạt các lệnh khác có thể được thực hiện với RC522. Do đó, hãy tham khảo các hướng dẫn sau:

Bài hướng dẫn và các project

>>> 100+ Mã Sản Phẩm Dây Rút: https://mecsu.vn/san-pham/day-rut-nhua.5op

>>> 1000+ Mã Sản Phẩm Đầu Cosse: https://mecsu.vn/san-pham/dau-cosse.Q1j

>>> Mời anh em xem thêm

Have you ever wondered how the antitheft system in a supermarket works? Or how do automatic toll payment systems like fast tag work? All the answer to your doubts is RFID or Radio Frequency Identification. As the name indicates, RFID uses electromagnetic waves in the radio frequency spectrum for communication and data transfer. RFID tags are used in many industries and you can find them in product tags from stores to security access cards. RFID tags can expedite the checkout and can be used for antitheft measures. They can be also used for identifying livestock, products, etc. In this tutorial, we will learn how we can use the RFID technology with the Arduino. We will learn how to interface an RC522 RFID reader with the Arduino.

RC522 RFID Reader/Writer Module Pinout

The RC522 module has a total of 8 pins. This module supports various communication protocols and each pin has a different function for each communication protocol. The pinout of a RFID Reader module is as follows:

SDA SCL I2C Communication pins. DATA and CLOCK.

SS SCK MOSI MISO SPI communication pins. Slave Select, Clock, MOSI, and MISO.

RX TX UART Communication pins.

IRQ Interrupt signal from the module to indicate RFID tag detection.

GND Ground pin that needs to be connected to the GND pin on the Arduino.

RST Reset pin for the module

VCC Supply pin for the module. The supply voltage can be anywhere from 2.5V to 3.3V and must be connected to the 3.3V pin on the Arduino.

RC522 RFID Reader/Writer Module – Parts

The RC522 module consists of an MFRC522 RFID chip from NXP. It is clocked at 27.12MHz by the onboard crystal oscillator in the 49S package. The board also consists of the required EMI filter circuit and matching circuit. It also consists of a PCB antenna for communicating and energizing the RFID tags.

RC522 RFID Reader/Writer Module Circuit Diagram

The Schematic diagram for the RC522 module is given below. The circuit consists of bare minimum components. As we know the main component is the MFRC522 chip. The remaining components form the EMI filter along with the matching circuit for the antenna.

How is the RFID Works?

The RFID system is comprised of two components: the RFID reader and the tags. They are also called PCD (Proximity Coupling Device) and PICC (Proximity Integrated Circuit Card).

The RFID reader consists of an antenna to emit high-frequency EM waves and a reader/writer. MFRC522 from NXP is an example of such an integrated circuit. Since we are using high-frequency waves in the megahertz range, the size of the antenna can be small.

The RFID tag can be either passive or active. Active tags are powered by batteries while the passive RFID tags are powered by energy from the reader’s interrogating EM waves. The tags are available in different forms or shapes like cards, tags, key forbs, or stickers. Whatever the shape, the RFID tag will consist of an antenna and the RFID chip, which will store all the data. When triggered by an electromagnetic interrogation pulse from a nearby RFID reader, the tag will transmit data back to the reader. The reader will then analyze this data to identify the tag. Unlike a barcode or a QR code, the tag does not need to be within the reader’s line of sight. This makes it easier to process and can be used for tracking objects in closed space.

Commonly Asked Questions about RFID Reader

What is an RFID used for?

RFID tags are a type of tracking system that uses radiofrequency to search, identify, track, and communicate with items and people.

How is RFID used in healthcare?

RFID helps to mitigate drug counterfeiting, simplifies the clinical trial process, improves the accuracy of patient identification, eases inventory management, streamlines patient tracking, improves communications between caregivers and patients, and eradicates the risk of administering the wrong medications.

Can Wi-Fi interfere with RFID?

Interference from other radio-frequency (RF) emitting devices (RFI), such as other RFID readers and Wi-Fi access points, can negatively impact RFID system performance.

RC522 RFID Reader Module

The RC522 RFID module is based on the popular MFRC522 RFID reader chip from NXP. These modules are cheap and available from most online stores. MFRC522 is a highly integrated RFID reader/writer IC for contactless communication at 13.56 MHz. The MFRC522 reader supports ISO/IEC 14443 A/MIFARE and NTAG. The operating voltage of the RC522 module is 2.5V – 3.3V. Even though the maximum supply voltage is 3.3V the communication pins are 5V tolerant. So, we can connect the module directly to an Arduino without any Level-Shifters.

The MFRC522 supports three different communication protocols:

• SPI with Speed up to 10Mbit/s
• I2C interface with speed up to 400kBd in Fast mode and up to 3400kBd in High-Speed mode
• RS232 Serial UART with speed up to 1228.8kBd

The RC522 module usually comes with an RFID card and a key fob. And each of these comes with a 1KB of memory. We can not only read these tags but can also program these with the RC522 module. Here is the picture showing the tags along with the RC522 module.

Arduino RC522 RFID Reader Interfacing Circuit Diagram

For interfacing the RC522 RFID module with the Arduino, we will be using the SPI interface. Follow the circuit diagram and make the connections as per that.

The VCC and GND pins of the module are connected to the 3.3V and GND pins of Arduino respectively. The Reset pin is connected to the D9 and SS, MOSI, MISO, and SCK pins are connected to the D10, D11, D12, and D13 pins of the Arduino respectively. The SS and RST pins are configurable and can be connected to any other digital pins on the Arduino.

Arduino RC522 RFID Module Code

As the connections are made, let’s look at the coding part. For that, we are going to use the MFRC522 Arduino Library by Miguel André Balboa. Since the library is not available in the Arduino library manager, download it from the MFRC522 GitHub repository and install it in the Arduino library folder. You can install it either through the Arduino IDE, by going to Sketch -> Include Library -> Add ZIP Library and selecting the downloaded .ZIP file, or by just simply extracting the Zip file into the Arduino library folder.

Once the library is installed, we can test our setup with an example code. For that, open the DumpInfo example from the MFRC522 library. Here is the example code.

#include

#include

#define RST_PIN 9 // Configurable, see typical pin layout above #define SS_PIN 10 // Configurable, see typical pin layout above MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance void setup() { Serial.begin(115200); // Initialize serial communications with the PC while (!Serial); // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4) SPI.begin(); // Init SPI bus mfrc522.PCD_Init(); // Init MFRC522 delay(4); // Optional delay. Some board do need more time after init to be ready, see Readme mfrc522.PCD_DumpVersionToSerial(); // Show details of PCD – MFRC522 Card Reader details Serial.println(F(“Scan PICC to see UID, SAK, type, and data blocks…”)); } void loop() { // Reset the loop if no new card present on the sensor/reader. This saves the entire process when idle. if ( ! mfrc522.PICC_IsNewCardPresent()) { return; } // Select one of the cards if ( ! mfrc522.PICC_ReadCardSerial()) { return; } // Dump debug info about the card; PICC_HaltA() is automatically called mfrc522.PICC_DumpToSerial(&(mfrc522.uid)); }

Once it’s compiled and uploaded to the Arduino, open the serial monitor and show any tag near the RC522 module. When the tag is in the vicinity, the reader will read all the data from the tag and will dump it into the serial monitor as shown below.

The data dump will contain all the details like Card UID, Card SAK, PICC type, and all the memory maps. The UID or Unique ID is Unique for each tag as the name suggests. If you get any communication failed error, that’s because our serial baud rate is too slow. Increase the baud rate to 115200 in the code and it will resolve the issue. Here in the data dump, we can see that the PICC type is MIFARE 1KB. That means the tag contains a MIFARE chip with a memory of 1KB.

Writing data to the RFID tag

Now that we have dumped the factory data from the tag, let’s see how we can write some data to the card. For that use the following code.

#include

//include the SPI library #include

//include the MFRC522 RFID reader library #define RST_PIN 9 //reset pin, which can be changed to another digital pin if needed. #define SS_PIN 10 //SS or the slave select pin, which can be changed to another digital pin if needed. MFRC522 mfrc522(SS_PIN, RST_PIN); // create a MFRC522 instant. MFRC522::MIFARE_Key key; //create a MIFARE_Key struct named ‘key’ to hold the card information byte data1[14] = {“Circuit-Digest”}; //The first data that needs to be written to the tag. byte data2[12] = {“Jobit-Joseph”}; //The second data that needs to be written to the tag. byte readbackblock[18]; //Array for reading out a block. void setup() { Serial.begin(115200); // Initialize serial communications with the PC SPI.begin(); // Init SPI bus mfrc522.PCD_Init(); // Init MFRC522 card (in case you wonder what PCD means: proximity coupling device) Serial.println(“Scan a MIFARE Classic card”); for (byte i = 0; i < 6; i++) { key.keyByte[i] = 0xFF; // Prepare the security key for the read and write operations. } } void loop() { // Look for new cards if not found rerun the loop function if ( ! mfrc522.PICC_IsNewCardPresent()) { return; } // read from the card if not found rerun the loop function if ( ! mfrc522.PICC_ReadCardSerial()) { return; } Serial.println(“card detected. Writing data”); writeBlock(1, data1); //write data1 to the block 1 of the tag writeBlock(2, data2); //write data2 to the block 2 of the tag Serial.println(“reading data from the tag”); readBlock(1, readbackblock); //read block 1 //print data Serial.print(“read block 1: “); for (int j = 0 ; j < 14 ; j++) { Serial.write (readbackblock[j]); } Serial.println(“”); readBlock(2, readbackblock); //read block 2 //print data Serial.print(“read block 2: “); for (int j = 0 ; j < 12 ; j++) { Serial.write (readbackblock[j]); } Serial.println(“”); //mfrc522.PICC_DumpToSerial(&(mfrc522.uid));//uncomment below line if want to see the entire memory dump. } //Write specific block int writeBlock(int blockNumber, byte arrayAddress[]) { //check if the block number corresponds to data block or triler block, rtuen with error if it’s trailer block. int largestModulo4Number = blockNumber / 4 * 4; int trailerBlock = largestModulo4Number + 3; //determine trailer block for the sector if (blockNumber > 2 && (blockNumber + 1) % 4 == 0) { Serial.print(blockNumber); Serial.println(” is a trailer block: Error”); return 2; } //authentication byte status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid)); if (status != MFRC522::STATUS_OK) { Serial.print(“Authentication failed: “); Serial.println(mfrc522.GetStatusCodeName(status)); return 3;//return “3” as error message } //writing data to the block status = mfrc522.MIFARE_Write(blockNumber, arrayAddress, 16); //status = mfrc522.MIFARE_Write(9, value1Block, 16); if (status != MFRC522::STATUS_OK) { Serial.print(“Data write failed: “); Serial.println(mfrc522.GetStatusCodeName(status)); return 4;//return “4” as error message } Serial.print(“Data written to block “); Serial.println(blockNumber); } //Read specific block int readBlock(int blockNumber, byte arrayAddress[]) { int largestModulo4Number = blockNumber / 4 * 4; int trailerBlock = largestModulo4Number + 3; //determine trailer block for the sector //authentication of the desired block for access byte status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid)); if (status != MFRC522::STATUS_OK) { Serial.print(“Authentication failed : “); Serial.println(mfrc522.GetStatusCodeName(status)); return 3;//return “3” as error message } //reading data from the block byte buffersize = 18; status = mfrc522.MIFARE_Read(blockNumber, arrayAddress, &buffersize);//&buffersize is a pointer to the buffersize variable; MIFARE_Read requires a pointer instead of just a number if (status != MFRC522::STATUS_OK) { Serial.print(“Data read failed: “); Serial.println(mfrc522.GetStatusCodeName(status)); return 4;//return “4” as error message } Serial.println(“Data read successfully”); }

Once the code is compiled and uploaded, open the serial monitor. Then scan a tag with the module. The module will write two data to the tag and will read back once it’s written. This data will be then printed to the serial monitor. See the screenshot below.

Code Explanation

In the first lines, we have included the necessary libraries and defined the reset and SS pins. Since we are using the SPI protocol, we have included the SPI library and then the MFRC522 library for the RFID reader. The reset and SS pins can be connected to any other digital pin. The users may change it at their convenience.

#include

//include the SPI library #include

//include the MFRC522 RFID reader library #define RST_PIN 9 //reset pin, which can be changed to another digital pin if needed. #define SS_PIN 10 //SS or the slave select pin, which can be changed to another digital pin if needed.

Next, we have created the objects for the RFID reader library and declared the data that’s needed to be written. Also, declared an array to hold the data that was read from the tag.

MFRC522 mfrc522(SS_PIN, RST_PIN); // create a MFRC522 instant. MFRC522::MIFARE_Key key; //create a MIFARE_Key struct named ‘key’ to hold the card information byte data1[14] = {“Circuit-Digest”}; //The first data that needs to be written to the tag. byte data2[12] = {“Jobit-Joseph”}; //The second data that needs to be written to the tag. byte readbackblock[18]; //Array for reading out a block.

In the setup() function, we have initialized the serial communication, SPI, and the RFID reader library. We have also cleared the key array with blank data for reading and writing operations.

void setup() { Serial.begin(115200); // Initialize serial communications with the PC SPI.begin(); // Init SPI bus mfrc522.PCD_Init(); // Init MFRC522 card (in case you wonder what PCD means: proximity coupling device) Serial.println(“Scan a MIFARE Classic card”); for (byte i = 0; i < 6; i++) { key.keyByte[i] = 0xFF; // Prepare the security key for the read and write operations. } }

The function we are using to write data to the tag is the writeblock function. When this function is called, it will check if the provided block number corresponds to the data block or the trailer block. The trailer block will hold the Access Bit which controls the read and write access to the reaming blocks. Block number 3 is the trailer block. If the provided block number does not correspond to a data block, the function will return an error message. If it’s a data block, the function will authenticate the tag with a security key and if the authentication is successful, the data will be written to the corresponding block.

int writeBlock(int blockNumber, byte arrayAddress[]) { //check if the block number corresponds to data block or triler block, rtuen with error if it’s trailer block. int largestModulo4Number = blockNumber / 4 * 4; int trailerBlock = largestModulo4Number + 3; //determine trailer block for the sector if (blockNumber > 2 && (blockNumber + 1) % 4 == 0) { Serial.print(blockNumber); Serial.println(” is a trailer block: Error”); return 2; } //authentication byte status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid)); if (status != MFRC522::STATUS_OK) { Serial.print(“Authentication failed: “); Serial.println(mfrc522.GetStatusCodeName(status)) return 3;//return “3” as error message } //writing data to the block status = mfrc522.MIFARE_Write(blockNumber, arrayAddress, 16); //status = mfrc522.MIFARE_Write(9, value1Block, 16); if (status != MFRC522::STATUS_OK) { Serial.print(“Data write failed: “); Serial.println(mfrc522.GetStatusCodeName(status)); return 4;//return “4” as error message } Serial.print(“Data written to block “); Serial.println(blockNumber); }

For reading data from the tag, we are using the readBlock function. It is similar to the write function. Once the function is called, it will determine the trailer block for the sector and then it will authenticate. If the authentication is successful, the function will read the data from the tag.

int readBlock(int blockNumber, byte arrayAddress[]) { int largestModulo4Number = blockNumber / 4 * 4; int trailerBlock = largestModulo4Number + 3; //determine trailer block for the sector //authentication of the desired block for access byte status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid)); if (status != MFRC522::STATUS_OK) { Serial.print(“Authentication failed : “); Serial.println(mfrc522.GetStatusCodeName(status)); return 3;//return “3” as error message } //reading data from the block byte buffersize = 18; status = mfrc522.MIFARE_Read(blockNumber, arrayAddress, &buffersize);//&buffersize is a pointer to the buffersize variable; MIFARE_Read requires a pointer instead of just a number if (status != MFRC522::STATUS_OK) { Serial.print(“Data read failed: “); Serial.println(mfrc522.GetStatusCodeName(status)); return 4;//return “4” as error message } Serial.println(“Data read successfully”); }

In the loop function, the microcontroller will check if a tag is present or not periodically. If a tag is present and readable, the function will write two data arrays to the tag, and then it will read back and printed to the serial monitor.

void loop() { // Look for new cards if not found rerun the loop function if ( ! mfrc522.PICC_IsNewCardPresent()) { return; } // read from the card if not found rerun the loop function if ( ! mfrc522.PICC_ReadCardSerial()) { return; } Serial.println(“card detected. Writing data”); writeBlock(1, data1); //write data1 to the block 1 of the tag writeBlock(2, data2); //write data2 to the block 2 of the tag Serial.println(“reading data from the tag”); readBlock(1, readbackblock); //read block 1 //print data Serial.print(“read block 1: “); for (int j = 0 ; j < 14 ; j++) { Serial.write (readbackblock[j]); } Serial.println(“”); readBlock(2, readbackblock); //read block 2 //print data Serial.print(“read block 2: “); for (int j = 0 ; j < 12 ; j++) { Serial.write (readbackblock[j]); } Serial.println(“”); //mfrc522.PICC_DumpToSerial(&(mfrc522.uid));//uncomment below line if want to see the entire memory dump. }

Turn On and Off LED with RFID

For this, connect an LED to the Arduino pin D8 through a current limiting resistor as shown below.

Arduino Code to Turn On or Off LED with RFID

Now let’s look at the code. The code is pretty simple. The RFID reader will check for any tags in the vicinity and if a tag is found, the reader will read the Unique ID from the tag. And if the UID matches with the UID in the code, the Arduino will toggle the LED state.

#include

#include

#define SS_PIN 10 #define RST_PIN 9 #define LED 8 byte readCard[4]; String tag_UID = “39C3BB99”; // Replace this with the UID of your tag!!! String tagID = “”; MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance void setup() { pinMode(LED, OUTPUT);// initialize digital pin LED_BUILTIN as an output. digitalWrite(LED, LOW); // turn the LED off by making the voltage LOW Serial.begin(115200); // Initialize serial communications with the PC SPI.begin(); // SPI bus mfrc522.PCD_Init(); // Initialise MFRC522 } void loop() { //Wait until new tag is available while (readID() { if (tagID == tag_UID) { digitalWrite(LED, !digitalRead(LED)); // Turn on or off the onboard led } } } //Read new tag if available boolean readID() { //Check if a new tag is detected or not. If not return. if ( ! mfrc522.PICC_IsNewCardPresent()) { return false; } //Check if a new tag is readable or not. If not return. if ( ! mfrc522.PICC_ReadCardSerial()) { return false; } tagID = “”; // Read the 4 byte UID for ( uint8_t i = 0; i < 4; i++) { //readCard[i] = mfrc522.uid.uidByte[i]; tagID.concat(String(mfrc522.uid.uidByte[i], HEX)); // Convert the UID to a single String } tagID.toUpperCase(); mfrc522.PICC_HaltA(); // Stop reading return true; }

Code Explanation

At first, we have included all the necessary libraries, declared the global variables, and created an instance for the RFID library.

#include

#include

#define SS_PIN 10 #define RST_PIN 9 #define LED 8 byte readCard[4]; String tag_UID = “39C3BB99”; // Replace this with the UID of your tag!!! String tagID = “”; MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance

Here the LED pin is connected to the Arduino pin D8. The tag_UID is unique for each tag and replace it with your own tag’s UID. You can get the UID by using the Dumpinfo example.

In the setup() function, we have initialized the pin D8 as an output and set its initial state to LOW. And then initialized the SPI bus and the MFRC522 instance.

void setup() { pinMode(LED, OUTPUT);// initialize digital pin LED_BUILTIN as an output. digitalWrite(LED, LOW); // turn the LED off by making the voltage LOW SPI.begin(); // SPI bus mfrc522.PCD_Init(); // Initialise MFRC522 }

The function readID is used to get the UID from the tags. This function will check if a tag is available or not and if a tag is available, it will read the UID from the tag. Then the UID is converted to a string and it’s stored in a variable called tagID. The readID function will return true if the reading was a success.

boolean readID() { //Check if a new tag is detected or not. If not return. if ( ! mfrc522.PICC_IsNewCardPresent() { return false; } //Check if a new tag is readable or not. If not return. if ( ! mfrc522.PICC_ReadCardSerial()) { return false; } tagID = “”; // Read the 4 byte UID for ( uint8_t i = 0; i < 4; i++) { //readCard[i] = mfrc522.uid.uidByte[i]; tagID.concat(String(mfrc522.uid.uidByte[i], HEX)); // Convert the UID to a single String } tagID.toUpperCase(); mfrc522.PICC_HaltA(); // Stop reading return true; }

In the loop function, the Arduino will check for a valid tag reading periodically. If it receives a valid tag reading the read UID matches with the UID we have declared earlier, the LED state will be toggled.

void loop() { //Wait until new tag is available while (readID()) { if (tagID == tag_UID) { digitalWrite(LED, !digitalRead(LED)); // Turn on or off the onboard led } } }

Projects Using RFID

There are some interesting projects done with the RFID. If you want to know more about those topics, links are given below.

This RFID Based IoT Enabled Event Management System not only monitors the entry log but with the help of IoT technology it can also send the Log and Entry data directly to a dedicated server that can handle all the authentication, authorization, and management making the whole process seamless.

In this RFID based Attendance System project, we will explain how we can count attendance automatically by using RFID cards. You can also find a step-by-step guide along with circuit and code to build your own attendance system.

Here in this project, we are using Arduino and relay to trigger the Electric Door Lock and RFID to authenticate, so your RFID tag will act as a key. If you place the wrong RFID card near the RFID reader a buzzer will beep to alert you about the wrong card.

Supporting Files

LED Control

#include

#include

#define SS_PIN 10 #define RST_PIN 9 #define LED 8 byte readCard[4]; String tag_UID = “39C3BB99”; // Replace this with the UID of your tag!!! String tagID = “”; MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance void setup() { pinMode(LED, OUTPUT);// initialize digital pin LED_BUILTIN as an output. digitalWrite(LED, LOW); // turn the LED off by making the voltage LOW SPI.begin(); // SPI bus mfrc522.PCD_Init(); // Initialise MFRC522 } void loop() { //Wait until new tag is available while (readID()) { if (tagID == tag_UID) { digitalWrite(LED, !digitalRead(LED)); // Turn on or off the onboard led } } } //Read new tag if available boolean readID() { //Check if a new tag is detected or not. If not return. if ( ! mfrc522.PICC_IsNewCardPresent()) { return false; } //Check if a new tag is readable or not. If not return. if ( ! mfrc522.PICC_ReadCardSerial()) { return false; } tagID = “”; // Read the 4 byte UID for ( uint8_t i = 0; i < 4; i++) { //readCard[i] = mfrc522.uid.uidByte[i]; tagID.concat(String(mfrc522.uid.uidByte[i], HEX)); // Convert the UID to a single String } tagID.toUpperCase(); mfrc522.PICC_HaltA(); // Stop reading return true; }

Write:

#include

//include the SPI library #include

//include the MFRC522 RFID reader library #define RST_PIN 9 //reset pin, which can be changed to another digital pin if needed. #define SS_PIN 10 //SS or the slave select pin, which can be changed to another digital pin if needed. MFRC522 mfrc522(SS_PIN, RST_PIN); // create a MFRC522 instant. MFRC522::MIFARE_Key key; //create a MIFARE_Key struct named ‘key’ to hold the card information byte data1[14] = {“Circuit-Digest”}; //The first data that needs to be written to the tag. byte data2[12] = {“Jobit-Joseph”}; //The second data that needs to be written to the tag. byte readbackblock[18]; //Array for reading out a block. void setup() { Serial.begin(115200); // Initialize serial communications with the PC SPI.begin(); // Init SPI bus mfrc522.PCD_Init(); // Init MFRC522 card (in case you wonder what PCD means: proximity coupling device) Serial.println(“Scan a MIFARE Classic card”); for (byte i = 0; i < 6; i++) { key.keyByte[i] = 0xFF; // Prepare the security key for the read and write operations. } } void loop() { // Look for new cards if not found rerun the loop function if ( ! mfrc522.PICC_IsNewCardPresent()) { return; } // read from the card if not found rerun the loop function if ( ! mfrc522.PICC_ReadCardSerial()) { return; } Serial.println(“card detected. Writing data”); writeBlock(1, data1); //write data1 to the block 1 of the tag writeBlock(2, data2); //write data2 to the block 2 of the tag Serial.println(“reading data from the tag”); readBlock(1, readbackblock); //read block 1 //print data Serial.print(“read block 1: “); for (int j = 0 ; j < 14 ; j++) { Serial.write (readbackblock[j]); } Serial.println(“”); readBlock(2, readbackblock); //read block 2 //print data Serial.print(“read block 2: “); for (int j = 0 ; j < 12 ; j++) { Serial.write (readbackblock[j]); } Serial.println(“”); //mfrc522.PICC_DumpToSerial(&(mfrc522.uid));//uncomment below line if want to see the entire memory dump. } //Write specific block int writeBlock(int blockNumber, byte arrayAddress[]) { //check if the block number corresponds to data block or triler block, rtuen with error if it’s trailer block. int largestModulo4Number = blockNumber / 4 * 4; int trailerBlock = largestModulo4Number + 3; //determine trailer block for the sector if (blockNumber > 2 && (blockNumber + 1) % 4 == 0) { Serial.print(blockNumber); Serial.println(” is a trailer block: Error”); return 2; } //authentication byte status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid)); if (status != MFRC522::STATUS_OK) { Serial.print(“Authentication failed: “); Serial.println(mfrc522.GetStatusCodeName(status)); return 3;//return “3” as error message } //writing data to the block status = mfrc522.MIFARE_Write(blockNumber, arrayAddress, 16); //status = mfrc522.MIFARE_Write(9, value1Block, 16); if (status != MFRC522::STATUS_OK) { Serial.print(“Data write failed: “); Serial.println(mfrc522.GetStatusCodeName(status)); return 4;//return “4” as error message } Serial.print(“Data written to block “); Serial.println(blockNumber); } //Read specific block int readBlock(int blockNumber, byte arrayAddress[]) { int largestModulo4Number = blockNumber / 4 * 4; int trailerBlock = largestModulo4Number + 3; //determine trailer block for the sector //authentication of the desired block for access byte status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid)); if (status != MFRC522::STATUS_OK) { Serial.print(“Authentication failed : “); Serial.println(mfrc522.GetStatusCodeName(status)); return 3;//return “3” as error message } //reading data from the block byte buffersize = 18; status = mfrc522.MIFARE_Read(blockNumber, arrayAddress, &buffersize);//&buffersize is a pointer to the buffersize variable; MIFARE_Read requires a pointer instead of just a number if (status != MFRC522::STATUS_OK) { Serial.print(“Data read failed: “); Serial.println(mfrc522.GetStatusCodeName(status)); return 4;//return “4” as error message } Serial.println(“Data read successfully”); }

RFID stands for radio frequency identification and it basically uses the radio waves to read the information on the tag. The RFID tags contains the embedded transmitter and receiver attached to an object. RFID is fast and does not require any contact between the reader and the tag and they can be read from feet’s away.

An RFID system consists of two parts: Tag and Reader

Circuit

Reading Data from a RFID tag

After having the circuit ready, go to File > Examples > MFRC522 > DumpInfo and upload the code. This code will be available in your Arduino IDE (after installing the RFID library).

Then, open the serial monitor. You should see something like the figure below:

Approximate the RFID card or the keychain to the reader. Let the reader and the tag closer until all the information is displayed.

This is the information that you can read from the card, including the card UID that is highlighted in yellow. The information is stored in the memory that is divided into segments and blocks as you can see in the previous picture.

You have 1024 bytes of data storage divided into 16 sectors and each sector is protected by two different keys, A and B.

Write down your UID card because you’ll need it later.

Upload the following code.


/* * * All the resources for this project: https://randomnerdtutorials.com/ * Modified by Rui Santos * * Created by FILIPEFLOP * */ #include

#include

#define SS_PIN 10 #define RST_PIN 9 MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance. void setup() { Serial.begin(9600); // Initiate a serial communication SPI.begin(); // Initiate SPI bus mfrc522.PCD_Init(); // Initiate MFRC522 Serial.println("Approximate your card to the reader..."); Serial.println(); } void loop() { // Look for new cards if ( ! mfrc522.PICC_IsNewCardPresent()) { return; } // Select one of the cards if ( ! mfrc522.PICC_ReadCardSerial()) { return; } //Show UID on serial monitor Serial.print("UID tag :"); String content= ""; byte letter; for (byte i = 0; i < mfrc522.uid.size; i++) { Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "); Serial.print(mfrc522.uid.uidByte[i], HEX); content.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ")); content.concat(String(mfrc522.uid.uidByte[i], HEX)); } Serial.println(); Serial.print("Message : "); content.toUpperCase(); if (content.substring(1) == "BD 31 15 2B") //change here the UID of the card/cards that you want to give access { Serial.println("Authorized access"); Serial.println(); delay(3000); } else { Serial.println(" Access denied"); delay(3000); } }




In the piece of code above you need to change the if (content.substring(1) == “REPLACE WITH YOUR UID”) and type the UID card you’ve written previously.

Keywords searched by users: rfid rc522 arduino uno code

Categories: Khám phá 73 Rfid Rc522 Arduino Uno Code

See more here: kientrucannam.vn

See more: https://kientrucannam.vn/vn/