ST25R3916 Documentation covers quick start steps, SPI wiring, ESP32 setup, reading performance notes, protocol support, and troubleshooting for the ELECHOUSE ST25R3916 NFC Reader Module.
Quick Start
- For first bring-up, use the module in its default SPI mode.
- Wire the board to your host MCU using MOSI, MISO, SCLK, CS, IRQ, 5V, and GND.
- Install the current ELECHOUSE ST25R3916 GitHub library package, including both the
ST25R3916_ELECHOUSEandNFC-RFALlibrary folders. - Open a real example from the library, such as
ESP32_SPI_scan_14443A_ledorESP32_SPI_scan_14443AB_15693. - Compile, upload, open Serial Monitor at 115200 baud, and present a tag to confirm detection and SPI communication.
Key Technical Facts
- Reader IC: STMicroelectronics ST25R3916
- Operating frequency: 13.56 MHz
- Host interface: ELECHOUSE module defaults to SPI; I2C is available only after board configuration / I2C pad setup.
- Reader support: ISO 14443A/B, ISO 15693 / NFC-V, FeliCa / NFC-F, and NFC Forum Type 1–5 tag technologies in reader mode.
- Card emulation: IC-level NFC-A and NFC-F card-emulation support with active load modulation. NFC Forum Type 4 / HCE behavior requires host firmware and protocol-stack implementation.
- EMVCo: ST25R3916 chip-level EMVCo 3.0 analog and digital compliance. Final terminal certification still depends on the complete product design, antenna, firmware, software stack, and test process.
- Typical strength: strong RF performance and long reading distance, especially on ISO 15693 tags under suitable antenna/tag conditions.
SPI Wiring
| ESP32 Pin | ST25R3916 Pin | Notes |
|---|---|---|
| D23 / GPIO23 | MOSI | SPI MOSI |
| D19 / GPIO19 | MISO | SPI MISO |
| D18 / GPIO18 | SCLK | SPI clock |
| D5 / GPIO5 | CS | Chip select |
| D4 / GPIO4 | IRQ | Interrupt |
| VIN / 5V | 5V | Power input to module |
| GND | GND | Common ground |
Note: the table above is the classic ESP32 Dev Module wiring used by the ELECHOUSE SPI test guide. ESP32-S3 and ESP32-C3 examples in the GitHub library define their own pin constants near the top of each .ino file.
Supported Platforms
- ESP32 Dev Module, ESP32-S3, and ESP32-C3 examples in the ELECHOUSE library
- Arduino-class boards with stable SPI and enough RAM/flash for RFAL-based examples
- STM32 and other ARM MCUs using ST RFAL / ST25R3916 software as the integration base
- Raspberry Pi via SPI for low-level register access or custom Linux driver work
Initialization Method
- Install Arduino IDE and the ESP32 board package.
- Install the latest ELECHOUSE ST25R3916 library from GitHub.
- For quick SPI testing, open
ESP32_SPI_scan_14443A_led. For multi-protocol discovery, openESP32_SPI_scan_14443AB_15693. - Check board, port, upload speed, and the pin constants at the top of the selected example.
- Upload the sketch, open Serial Monitor at 115200, and test with a nearby NFC/RFID tag.
Example Test Workflow
# Arduino IDE baseline test flow
1. Install ESP32 board package
2. Install the ST25R3916_ELECHOUSE and NFC-RFAL library folders
3. Open ESP32_SPI_scan_14443A_led or ESP32_SPI_scan_14443AB_15693
4. Verify the sketch
5. Upload to ESP32
6. Open Serial Monitor at 115200
7. Tap a tag and watch UID / card-type output
Libraries and Resources
Reading Performance Highlights
Under ELECHOUSE test conditions with the on-board PCB antenna, the ST25R3916 module showed strong performance across multiple tag families:
- NTAG213 / NTAG216: about 6.5 cm
- FeliCa: about 5.0 cm
- MIFARE DESFire: about 2.8 cm
- ISO 15693 ICODE SLI-S: about 9.5 cm
- ISO 15693 ICODE SLIX2: up to 11.0 cm
Actual distance varies with tag type, antenna size, orientation, shielding, metal nearby, firmware configuration, and surrounding RF noise.
Common Errors
- No serial output: wrong COM / serial port or wrong baud rate.
- Sketch compiles with warnings: some architecture warnings may be harmless if upload and runtime behavior are correct.
- No LED blink / no UID: re-check CS and IRQ first, then MOSI / MISO / SCLK.
- Weak reading distance: tag is too far away, orientation is poor, tag antenna is small, or there is nearby metal / interference.
- I2C example does not respond: confirm the board has been configured for I2C mode first; the standard quick-start path is SPI.
Troubleshooting
- Start with the provided SPI LED / UID detection example before building a full application.
- Keep the tag close to the antenna during first tests.
- Double-check that MOSI and MISO are not swapped.
- Confirm your ESP32 is in normal run mode and Serial Monitor is set to 115200 baud.
- For multi-protocol testing, use the
ESP32_SPI_scan_14443AB_15693or card-profile examples from the current GitHub library.
Version Differences / Positioning
- Compared with PN532, ST25R3916 usually offers stronger high-performance reader behavior and much better ISO 15693 / NFC-V support.
- Compared with PN7160 / PN7161, ST25R3916 is a direct RF reader/front-end style platform for SPI/I2C-hosted embedded development, while PN7160 / PN7161 are NCI-controller products that are usually easier for Linux / Android / OS-integrated NFC workflows.
- For new ST25-based designs, also compare the ST25R3916B NFC Module, which uses the newer ST25R3916B reader IC.
Supported Protocols Detail
| Protocol / Tag Family | Standard / Technology | Typical Tag / Card | What the module can provide | Important note |
|---|---|---|---|---|
| MIFARE Classic | ISO 14443A-based, proprietary crypto | 1K / 4K key fobs | Detection, UID, authentication/read/write when supported by the library and keys | Requires correct keys and MIFARE Classic software support. |
| MIFARE DESFire EV1/EV2/EV3 | ISO 14443A / ISO-DEP | Secure access cards | Low-level ISO-DEP communication path | Secure file access requires application-layer APDUs, authentication, and key management. |
| NTAG 213/215/216 | ISO 14443A / NFC Forum Type 2 | NFC stickers, wristbands | Read/write with Type 2 tag software support | Write behavior depends on tag lock/password configuration. |
| ISO 14443B / Type 4B | ISO 14443B / ISO-DEP | ID cards, Type 4B tags, some payment-related cards | Detection and ISO-DEP communication when software support is implemented | Do not assume bank-card data is readable; payment applications require compliant EMV software and certification. |
| FeliCa / NFC-F | JIS X 6319 / NFC-F | Suica, Octopus, NFC Forum Type 3 | Reader/writer capability at IC level | Application behavior depends on the selected FeliCa service/system and host software. |
| ISO 15693 / NFC-V | ISO 15693 | ICODE SLI, ICODE SLIX2, industrial labels | Inventory, UID, read/write with supported tags and examples | Reading distance depends heavily on tag antenna size and environment. |
| NFC-A / NFC-F card emulation | ISO 14443A / NFC-F card-emulation modes | Host-driven emulation use cases | IC-level active load modulation support | NFC Forum Type 4 / HCE behavior requires a host-side firmware/protocol stack. |
Arduino / ESP32 Code Example
The current ELECHOUSE library does not use a simple ST25R3916 rfid(...) / readPassiveTargetID() API. Use the real RFAL-based examples from the GitHub repository. A minimal initialization skeleton looks like this:
#include <Arduino.h>
#include <SPI.h>
#include <rfal_nfc.h>
#include <rfal_rfst25r3916.h>
#include <st_errno.h>
SPIClass gSpi(VSPI);
RfalRfST25R3916Class gReader(&gSpi, 5, 4); // SS=GPIO5, IRQ=GPIO4
RfalNfcClass gNfc(&gReader);
void setup() {
Serial.begin(115200);
gSpi.begin(18, 19, 23, 5); // SCK, MISO, MOSI, SS
ReturnCode err = gNfc.rfalNfcInitialize();
if (err != ERR_NONE) {
Serial.print("rfalNfcInitialize failed: ");
Serial.println((int)err);
while (true) delay(250);
}
Serial.println("ST25R3916 RFAL initialized");
}
void loop() {
// For full UID printing and polling logic, use:
// ESP32_SPI_scan_14443A_led
// ESP32_SPI_scan_14443AB_15693
}
For real polling, UID formatting, activation/deactivation handling, and multi-protocol discovery, copy one of the complete examples from the GitHub repository instead of building from the skeleton above.
Reading ISO 15693 Tags
The ST25R3916 provides strong ISO 15693 / NFC-V reader performance compared with PN532-class modules. This makes it well-suited for industrial label reading and asset tracking.
Under ELECHOUSE test conditions, ICODE SLIX2 tags were readable at up to 11.0 cm, significantly exceeding typical small ISO 14443 card read ranges. This is a module-and-tag test result, not a guaranteed minimum distance for every installation.
Card Emulation
The ST25R3916 supports NFC-A and NFC-F card emulation at IC level. In card-emulation mode, the transmitter can actively generate the load-modulation signal, which is useful for robust emulation setups.
Do not treat this as a complete turnkey HCE product. NFC Forum Type 4 behavior, NDEF behavior, secure-card behavior, or access-control proof-of-concept behavior must be implemented in host firmware/software and validated with the target reader system.
Raspberry Pi Wiring (SPI)
| ST25R3916 Pin | Raspberry Pi | Notes |
|---|---|---|
| MOSI | Pin 19 (MOSI / GPIO10) | SPI data to module |
| MISO | Pin 21 (MISO / GPIO9) | SPI data from module |
| SCLK | Pin 23 (SCLK / GPIO11) | SPI clock |
| CS | Pin 24 (CE0 / GPIO8) | Chip select |
| IRQ | Pin 22 (GPIO25) | Interrupt (any free GPIO) |
| 5V | Pin 2 or 4 (5V) | Power supply |
| GND | Pin 6 | Common ground |
Enable SPI with sudo raspi-config → Interface Options → SPI. Raspberry Pi examples are best treated as custom integration work unless you are using an existing ST25R3916 Linux/RFAL port.
Raspberry Pi Python Example — SPI Register Check
This example only checks low-level SPI communication by reading the ST25R3916 IC identity register. It is not a full NFC polling implementation.
import spidev
spi = spidev.SpiDev()
spi.open(0, 0) # bus 0, CE0
spi.max_speed_hz = 4000000
spi.mode = 0b01 # ST25R3916 SPI: CPOL=0, CPHA=1
# ST25R3916 register read: set bit 6 for read, bits 5:0 for address
# IC Identity register is register 0x3F in register space A.
def read_reg(addr):
cmd = [0x40 | (addr & 0x3F), 0x00]
resp = spi.xfer2(cmd)
return resp[1]
identity = read_reg(0x3F)
ic_type = (identity >> 3) & 0x1F
revision = identity & 0x07
print(f"IC_IDENTITY = 0x{identity:02X}, type={ic_type}, rev={revision}")
# ST25R3916 type code: 0b00101 (5)
# ST25R3916B type code: 0b00110 (6)
spi.close()
For tag polling, anti-collision, ISO-DEP, NFC-V inventory, and NDEF operations, use ST RFAL or a tested community driver instead of raw register reads.
Low Power Card Detection Modes
At IC level, ST25R3916 supports low-power card detection techniques including capacitive sensing, amplitude detection, and phase detection. For the standard ELECHOUSE module, use antenna-based amplitude / phase detection as the practical path.
| Mode | How It Works | Module note |
|---|---|---|
| Capacitive sensing | Uses dedicated CSO/CSI capacitive sensor electrodes at IC level. | The standard ELECHOUSE module does not expose CSO/CSI on the connector, so do not advertise this as standard module capacitive wake-up. |
| Amplitude detection | Briefly turns on RF and measures load/amplitude change. | Useful for antenna-based low-power card detection. |
| Phase detection | Briefly turns on RF and measures phase shift. | Useful for antenna-based low-power card detection, including more difficult RF environments. |
EMVCo 3.0 Compliance
The ST25R3916 chip is EMVCo 3.0 analog and digital compliant at chip level. This is useful for payment-terminal prototyping and payment-adjacent reader design work.
However, the ELECHOUSE module itself should not be described as an already-certified payment terminal. Final EMVCo certification depends on the complete hardware design, antenna tuning, enclosure, firmware, payment software, and official lab testing.
Supply Voltage Flexibility
The ST25R3916 IC operates from a wide supply range:
- 2.4V to 5.5V (−20°C to +105°C)
- 2.6V to 5.5V (−40°C to +105°C)
- Peripheral IO voltage: 1.65V to 5.5V
The ELECHOUSE ST25R3916 module provides a 5V input with on-board regulation. For host logic, 3.3V MCU platforms such as ESP32 are the recommended quick-start target.
When to Choose ST25R3916
Choose ST25R3916 when your project needs direct high-performance NFC reader control, strong RF margin, ISO 15693 / NFC-V range, or embedded MCU integration where you are comfortable using RFAL-style examples and lower-level NFC software.
- Choose ST25R3916 / ST25R3916B for high-performance reader designs, ISO 15693 asset tracking, noisy RF environments, antenna-sensitive designs, or custom embedded products.
- Choose PN7160 / PN7161 when you prefer an NCI 2.0 controller workflow for Linux / Android / OS-integrated NFC stacks.
- Choose PN532 for simple Arduino projects where library availability and quick examples matter more than RF performance or ISO 15693 support.
ST25R3916 vs PN532 vs PN7160 — Technical Comparison
| Feature | ST25R3916 | PN7160 | PN532 |
|---|---|---|---|
| Product positioning | High-performance NFC reader/front-end platform | NCI 2.0 NFC controller with integrated firmware | Older, easy-to-use NFC controller/module ecosystem |
| ISO 15693 / NFC-V | Supported; NFC-V reader up to 53 kbps at IC level | Supported; ISO 15693 / ICODE VCD mode | Not supported by the PN532 datasheet feature set |
| FeliCa / NFC-F | Supported | Supported | Supported |
| EMVCo positioning | Chip-level EMVCo 3.0 analog/digital compliant | Not mainly positioned as an EMVCo reader IC on the product page; final compliance depends on complete design | Not an EMVCo reader platform |
| Low-power detection | Capacitive, amplitude, and phase techniques at IC level; standard module mainly uses antenna-based amplitude/phase paths | Integrated polling loop and RF field detection features | Basic low-power / wake-up features compared with newer ICs |
| Card emulation / load modulation | NFC-A / NFC-F card emulation with active load modulation support | Card emulation supported; active load modulation / enhanced DLMA features are described by NXP | Card operation modes for ISO14443A / MIFARE and FeliCa |
| Host interface | IC supports SPI and I2C; ELECHOUSE module defaults to SPI, I2C after board configuration | IC supports I2C-bus and SPI-bus; many modules expose a selected host interface | SPI / I2C / UART |
| Software path | ELECHOUSE examples + ST RFAL style integration | NCI stack / OS NFC integration | Large Arduino maker ecosystem |
Related Pages
- ST25R3916 Product Page
- ST25R3916B NFC Module
- PN532 vs PN7160 vs ST25R3916
- Best NFC Module for Arduino
- Best NFC Module for Raspberry Pi / Linux
Update History
- 2026-07-05: Accuracy update: fixed GitHub link, current library/example names, Raspberry Pi SPI mode and IC identity register, SPI/I2C wording, EMVCo wording, card-emulation wording, and PN7160 comparison details.
- 2026-04-05: First public ST25R3916 documentation page published.
- Reference basis: ELECHOUSE product page performance table, ELECHOUSE SPI test guide, current ELECHOUSE GitHub library, ST ST25R3916 / ST25R3916B datasheets, NXP PN7160 / PN7161 documentation, and PN532 datasheet.