How to Use RFID Reader Module: Integration Guide for MFRC522 and UHF Modules

You have a small PCB with a chip, an antenna trace, and a row of pins. It is not a finished reader with a case and beeper. It is a module—the guts of an RFID system meant to be embedded into your own project.

Here is the thing. When people search how to use RFID reader module, they usually discover that modules are different from finished readers. No USB plug-and-play. No mobile app. You have to wire it, talk to it over SPI or serial, and write code to interpret what comes back.

Let me walk through the real steps for using RFID modules, from the popular MFRC522 for HF to UHF modules for longer range.

First: Know Your Module Type

RFID modules come in different frequencies and interfaces. Your steps depend on which one you have.

MFRC522 (13.56 MHz HF): The most common hobbyist module. Reads Mifare cards, NFC tags. Uses SPI communication. Costs a few dollars. Good for access control, attendance systems, and learning .

UHF modules (860-960 MHz): For longer range (up to several meters). Often communicate over serial (UART) with simple ASCII commands. Used in inventory and tracking .

Low Frequency modules (125 kHz): For old proximity cards. Usually simple readers that just output the card ID over serial.

This guide focuses on the MFRC522 because that is what most people mean when they search how to use RFID reader module. But we will cover UHF modules too.

Step 1: Wiring the Module (MFRC522)

The MFRC522 uses SPI (Serial Peripheral Interface) to talk to your microcontroller. You need to connect four SPI pins plus power and reset .

For Raspberry Pi (40-pin header):

MFRC522 Pin	Raspberry Pi Pin	GPIO/Function
SDA (SS)	Pin 24	GPIO8 (CE0)
SCK	Pin 23	GPIO11 (SCLK)
MOSI	Pin 19	GPIO10 (MOSI)
MISO	Pin 21	GPIO9 (MISO)
IRQ	Not connected	–
GND	Pin 6 (or any GND)	Ground
RST	Pin 22	GPIO25
3.3V	Pin 1	3.3V power

Important: The MFRC522 runs on 3.3V, not 5V. Connecting to 5V will destroy the module .

For Arduino Uno:

MFRC522 Pin	Arduino Pin
SDA (SS)	Pin 10
SCK	Pin 13
MOSI	Pin 11
MISO	Pin 12
IRQ	Not connected
GND	GND
RST	Pin 9
3.3V	3.3V

The Arduino example from the MFRC522 library shows this exact wiring .

Step 2: Install Required Software

For Raspberry Pi with Python:

First, enable SPI on your Raspberry Pi :

bash

# In raspi-config, go to Interface Options > SPI > Enable
sudo raspi-config
# Reboot after enabling

Then install the required Python packages :

bash

# Install Python dev tools and SPI library
sudo apt update
sudo apt install python3-dev python3-pip
pip install spidev

# Install mfrc522 library
pip install mfrc522-python

The mfrc522-python library provides both low-level and simple interfaces .

For Arduino:

1. Open Arduino IDE
2. Go to Sketch > Include Library > Manage Libraries
3. Search for “MFRC522” by miguelbalboa
4. Install the library
5. Go to File > Examples > MFRC522 > DumpInfo to test 

Step 3: Read a Tag with Python (Simple Method)

The SimpleMFRC522 class makes reading tags incredibly easy :

python

#!/usr/bin/env python
from mfrc522 import SimpleMFRC522
import RPi.GPIO as GPIO

reader = SimpleMFRC522()

try:
    print("Place card near reader...")
    id, text = reader.read()
    print(f"Card UID: {id}")
    print(f"Stored text: {text}")
    
    # Write new text to the card
    new_text = "CYKEO-001"
    print(f"Writing: {new_text}")
    id, written = reader.write(new_text)
    print(f"Write complete. UID: {id}")

finally:
    GPIO.cleanup()

Run with sudo (needed for GPIO access) :

bash

sudo python3 read_card.py

If everything is wired correctly, you will see the card UID and any stored text.

Step 4: Understanding Card Memory (For Advanced Use)

Simple read gets the UID and first data block. But RFID cards have structured memory .

Mifare Classic 1K memory layout:

• 16 sectors (0 to 15)
• Each sector has 4 blocks of 16 bytes
• Total: 64 blocks, 1024 bytes

Important blocks to know :

• Block 0: Manufacturer data (read-only, contains UID)
• Blocks 3, 7, 11, etc.: “Trailer blocks” containing access keys
• Other blocks: User data storage

Never write to trailer blocks unless you know what you are doing. Writing incorrect data to a trailer block can lock the entire sector permanently .

For more control, use the MFRC522 class instead of SimpleMFRC522 :

python

from mfrc522 import MFRC522

reader = MFRC522()

# Request card
(status, TagType) = reader.Request(reader.PICC_REQIDL)
if status != reader.MI_OK:
    print("No card found")
    exit()

# Get UID
(status, uid) = reader.Anticoll()
if status == reader.MI_OK:
    print(f"UID: {uid}")
    
    # Select tag for authentication
    reader.SelectTag(uid)
    
    # Authenticate using default key
    key = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
    trailer_block = 11  # Sector 3 trailer
    status = reader.Authenticate(reader.PICC_AUTHENT1A, trailer_block, key, uid)
    
    if status == reader.MI_OK:
        # Read multiple blocks
        block_nums = [8, 9, 10]  # Sector 2 data blocks
        data = []
        for block_num in block_nums:
            block_data = reader.ReadTag(block_num)
            if block_data:
                data += block_data
        
        if data:
            print("Read data:", ''.join(chr(i) for i in data))
    
    reader.StopAuth()  # Always stop authentication

Step 5: Using UHF RFID Modules

UHF modules work differently. They typically communicate over serial (UART) and use ASCII commands .

Example with M5Stack UHF-RFID unit:

cpp

#include <M5Unified.h>
#include "UNIT_UHF_RFID.h"

Unit_UHF_RFID uhf;

void setup() {
    M5.begin();
    Serial.begin(115200);
    
    // Initialize UHF module on Serial2 with pins 1(RX) and 2(TX)
    uhf.begin(&Serial2, 115200, 1, 2, false);
    
    // Check communication
    String info = uhf.getVersion();
    if (info != "ERROR") {
        Serial.println("Module ready: " + info);
    }
    
    uhf.setTxPower(2600);  // Set power level
}

void loop() {
    // Poll for tags once
    uint8_t result = uhf.pollingOnce();
    
    if (result > 0) {
        for (uint8_t i = 0; i < result; i++) {
            Serial.println("EPC: " + uhf.cards[i].epc_str);
            Serial.println("RSSI: " + uhf.cards[i].rssi_str);
        }
    }
    
    delay(2000);
}

UHF modules can read tags from several meters away, unlike HF modules which need close contact .

Step 6: Write Data to Tags

Writing requires targeting the right memory location .

For HF tags with MFRC522:

python

# After authentication (see above)
block_nums = [8, 9, 10]
text = "PROD-12345"

# Pad to 16 bytes per block (16 * number of blocks)
data = bytearray()
data.extend(bytearray(text.ljust(len(block_nums) * 16).encode('ascii')))

i = 0
for block_num in block_nums:
    reader.WriteTag(block_num, data[(i*16):(i+1)*16])
    i += 1
print("Write complete")

For UHF tags with serial modules :

cpp

uint8_t write_buffer[] = {0xab, 0xcd, 0xef, 0xdd};
uint8_t reade_buffer[4] = {0};

if (uhf.writeCard(write_buffer, sizeof(write_buffer), 0x04, 0, 0x00000000)) {
    Serial.println("Write OK");
}

if (uhf.readCard(reade_buffer, sizeof(reade_buffer), 0x04, 0, 0x00000000)) {
    Serial.println("Read OK: " + String((char*)reade_buffer));
}

Common Problems and Solutions

Module not detected

• Check wiring—loose connections are the #1 cause 
• Verify power—MFRC522 needs 3.3V exactly
• Enable SPI in config (Raspberry Pi) 

Reads sometimes work, sometimes not

• Card distance—MFRC522 range is only a few cm
• Card orientation—rotate the card
• Interference—keep away from metal

Authentication fails

• Wrong key—default is usually FFFFFFFFFFFF, but cards may have custom keys
• Wrong sector—trailer block must match sector you want 
• Card type—some cards use different protocols

Write fails

• Card may be locked
• Writing to read-only block (block 0, trailer blocks)
• Not authenticated to that sector first

UHF module not responding

• Check serial baud rate (often 115200)
• Verify TX/RX connections are crossed (TX to RX, RX to TX)
• Power—UHF modules need more current than HF 

Complete Example: RFID Door Lock

Here is a complete Arduino example from a working door lock project :

cpp

#include <SPI.h>
#include <MFRC522.h>

#define SS_PIN 10
#define RST_PIN 9
#define LED_G 5
#define LED_R 4
#define RELAY 3
#define BUZZER 2
#define ACCESS_DELAY 2000
#define DENIED_DELAY 1000

MFRC522 mfrc522(SS_PIN, RST_PIN);

void setup() {
    Serial.begin(9600);
    SPI.begin();
    mfrc522.PCD_Init();
    
    pinMode(LED_G, OUTPUT);
    pinMode(LED_R, OUTPUT);
    pinMode(RELAY, OUTPUT);
    pinMode(BUZZER, OUTPUT);
    
    digitalWrite(RELAY, LOW);
    Serial.println("Ready - present card");
}

void loop() {
    // Look for new cards
    if (!mfrc522.PICC_IsNewCardPresent()) return;
    if (!mfrc522.PICC_ReadCardSerial()) return;
    
    // Read UID
    String content = "";
    for (byte i = 0; i < mfrc522.uid.size; i++) {
        content.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "));
        content.concat(String(mfrc522.uid.uidByte[i], HEX));
    }
    content.toUpperCase();
    
    // Check against authorized UID
    if (content.substring(1) == "83 23 38 BB") {
        Serial.println("Access granted");
        digitalWrite(RELAY, HIGH);
        digitalWrite(LED_G, HIGH);
        delay(ACCESS_DELAY);
        digitalWrite(RELAY, LOW);
        digitalWrite(LED_G, LOW);
    } else {
        Serial.println("Access denied");
        digitalWrite(LED_R, HIGH);
        tone(BUZZER, 300);
        delay(DENIED_DELAY);
        digitalWrite(LED_R, LOW);
        noTone(BUZZER);
    }
}

CYKEO Module Solutions

For production applications, CYKEO offers embedded RFID modules that integrate seamlessly:

CYKEO CM-UHF1: Compact UHF module with serial interface, 26dBm output, reads up to 8 meters. Simple ASCII command set for easy integration.

CYKEO CM-HF1: 13.56MHz module with SPI interface, compatible with MFRC522 code. Reads Mifare, NTAG, and ICODE tags.

CYKEO CM-LF1: 125kHz module for proximity cards. Simple 3-byte UART output—just connect and read.

All CYKEO modules come with:

• Full documentation and command sets
• Example code for Arduino, Raspberry Pi, and STM32
• Technical support from engineers

The Bottom Line

How to use RFID reader module comes down to:

1. Wire correctly—SPI for MFRC522, serial for UHF modules
2. Install libraries—mfrc522-python for Raspberry Pi, MFRC522 library for Arduino
3. Read with simple code—SimpleMFRC522 for basic UID access
4. Understand memory—sectors and blocks for HF, memory banks for UHF
5. Authenticate before writing—keys matter

Start with the DumpInfo example or SimpleMFRC522 to verify your module works. Then move to more advanced operations.

CYKEO modules are designed to be drop-in replacements for common modules, with better sensitivity and reliability. Our documentation includes migration guides for MFRC522 projects.

And when you get stuck—because RF is tricky—CYKEO support has helped hundreds of developers integrate RFID modules. Call us with your module type and what you are building.

---

Need an RFID module for your project?
CYKEO offers HF and UHF modules with full documentation and support. Contact our embedded team for datasheets and sample code.