ESP32 PN532 NFC Module

Code Examples

Below you can find code examples of PN532 NFC Module with ESP32 in several frameworks:

• Arduino IDE
• ESP-IDF
• ESPHome
• PlatformIO
• MicroPython

If you encounter issues while using the PN532 NFC Module, check the Common Issues Troubleshooting Guide.

ESP32 PN532 Arduino IDE Code Example

Example in Arduino IDE

Fill in your main Arduino IDE sketch file with the following code to use the PN532 NFC Module:

#include <Wire.h>
#include <Adafruit_PN532.h>

#define SDA_PIN 21
#define SCL_PIN 22
Adafruit_PN532 nfc(SDA_PIN, SCL_PIN);

void setup() {
    Serial.begin(115200);
    Serial.println("Initializing PN532...");
    nfc.begin();

    uint32_t version = nfc.getFirmwareVersion();
    if (!version) {
        Serial.println("Didn't find PN532 board");
        while (1);
    }

    nfc.SAMConfig();
    Serial.println("PN532 initialized!");
}

void loop() {
    Serial.println("Waiting for NFC tag...");
    uint8_t success;
    uint8_t uid[] = {0};
    uint8_t uidLength;

    success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength);
    if (success) {
        Serial.print("Found NFC tag with UID: ");
        for (uint8_t i = 0; i < uidLength; i++) {
            Serial.print(uid[i], HEX);
            Serial.print(" ");
        }
        Serial.println();
    }
    delay(1000);
}

This Arduino sketch interfaces with the PN532 NFC module over I2C using the Adafruit PN532 library. The `setup` function initializes the module, and the firmware version is retrieved for verification. In the `loop`, the module continuously scans for NFC tags and prints the UID of any detected tag. Additional features, such as writing to tags or handling other NFC modes, can be implemented as needed.

Connect your ESP32 to your computer via a USB cable, Ensure the correct Board and Port are selected under Tools, Click the "Upload" button in the Arduino IDE to compile and upload the code to your ESP32.

ESP32 PN532 ESP-IDF Code Example

Example in Espressif IoT Framework (ESP-IDF)

If you're using ESP-IDF to work with the PN532 NFC Module, here's how you can set it up and read data from the sensor. Fill in this code in the main ESP-IDF file:

#include <stdio.h>
#include "driver/i2c.h"
#include "esp_log.h"
#include "pn532.h"

#define I2C_MASTER_SCL_IO 22
#define I2C_MASTER_SDA_IO 21
#define I2C_MASTER_FREQ_HZ 100000

void app_main() {
    ESP_LOGI("PN532", "Initializing I2C");
    i2c_config_t i2c_conf = {
        .mode = I2C_MODE_MASTER,
        .sda_io_num = I2C_MASTER_SDA_IO,
        .sda_pullup_en = GPIO_PULLUP_ENABLE,
        .scl_io_num = I2C_MASTER_SCL_IO,
        .scl_pullup_en = GPIO_PULLUP_ENABLE,
        .master.clk_speed = I2C_MASTER_FREQ_HZ
    };

    i2c_param_config(I2C_NUM_0, &i2c_conf);
    i2c_driver_install(I2C_NUM_0, i2c_conf.mode, 0, 0, 0);

    PN532 pn532(I2C_NUM_0);
    if (!pn532.begin()) {
        ESP_LOGE("PN532", "Failed to initialize PN532 module");
        return;
    }

    ESP_LOGI("PN532", "Waiting for NFC tag...");
    while (1) {
        uint8_t uid[7];
        uint8_t uid_length;
        if (pn532.readPassiveTargetID(uid, &uid_length)) {
            ESP_LOGI("PN532", "Found NFC tag with UID: ");
            for (int i = 0; i < uid_length; i++) {
                printf("%02X ", uid[i]);
            }
            printf("\n");
        }
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

This ESP-IDF code initializes the PN532 NFC module over I2C. The module scans for NFC tags and logs their UIDs. The code configures the I2C master interface, connects to the PN532, and uses a continuous loop to detect tags. Additional functionalities, such as tag writing, can be implemented using the PN532 driver.

Update the I2C pins (I2C_MASTER_SDA_IO and I2C_MASTER_SCL_IO) to match your ESP32 hardware setup, Use idf.py build to compile the project, Use idf.py flash to upload the code to your ESP32.

ESP32 PN532 ESPHome Code Example

Example in ESPHome (Home Assistant)

Fill in this configuration in your ESPHome YAML configuration file (example.yml) to integrate the PN532 NFC Module

uart:
  tx_pin: GPIO17
  rx_pin: GPIO16
  baud_rate: 115200

pn532:
  update_interval: 2s

sensor:
  - platform: pn532
    uid:
      name: "NFC Tag UID"
    log:
      name: "NFC Log"

This ESPHome configuration sets up the PN532 NFC module. The module is updated every 2 seconds to scan for NFC tags. Detected tag UIDs are logged and available as a sensor output. The configuration can be extended for writing to tags or using NFC data in automations.

Upload this code to your ESP32 using the ESPHome dashboard or the esphome run command.

ESP32 PN532 PlatformIO Code Example

Example in PlatformIO Framework

For PlatformIO, make sure to configure the platformio.ini file with the appropriate environment and libraries, and then proceed with the code.

Configure platformio.ini

First, your platformio.ini should look like below. You might need to include some libraries as shown. Make sure to change the board to your ESP32:

[env:pn532]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200

ESP32 PN532 PlatformIO Example Code

Write this code in your PlatformIO project under the src/main.cpp file to use the PN532 NFC Module:

#include <Wire.h>
#include <Adafruit_PN532.h>

Adafruit_PN532 nfc(21, 22);

void setup() {
    Serial.begin(115200);
    nfc.begin();

    if (!nfc.getFirmwareVersion()) {
        Serial.println("Failed to find PN532!");
        while (1);
    }
    nfc.SAMConfig();
    Serial.println("Waiting for NFC tag...");
}

void loop() {
    uint8_t uid[7];
    uint8_t uidLength;
    if (nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength)) {
        Serial.print("Found NFC tag with UID: ");
        for (uint8_t i = 0; i < uidLength; i++) {
            Serial.print(uid[i], HEX);
            Serial.print(" ");
        }
        Serial.println();
    }
    delay(1000);
}

This PlatformIO example uses the Adafruit PN532 library to interface with the PN532 module over I2C. It initializes the module, scans for NFC tags, and logs their UIDs to the Serial Monitor. The code can be extended to include additional NFC features like tag writing or peer-to-peer communication.

Upload the code to your ESP32 using the PlatformIO "Upload" button in your IDE or the pio run --target upload command.

ESP32 PN532 MicroPython Code Example

Example in Micro Python Framework

Fill in this script in your MicroPython main.py file (main.py) to integrate the PN532 NFC Module with your ESP32.

from machine import I2C, Pin
import time
from pn532_i2c import PN532_I2C

# Initialize I2C
i2c = I2C(1, scl=Pin(22), sda=Pin(21))
pn532 = PN532_I2C(i2c, debug=False)

pn532.SAM_configuration()

while True:
    print("Waiting for NFC tag...")
    uid = pn532.read_passive_target()
    if uid:
        print("Found NFC tag with UID:", [hex(i) for i in uid])
    time.sleep(1)

This MicroPython code communicates with the PN532 module over I2C. The PN532_I2C library initializes the module and enables scanning for NFC tags. When a tag is detected, its UID is printed. Additional NFC functionalities like writing or peer-to-peer communication can be implemented.

Upload this code to your ESP32 using a MicroPython-compatible IDE, such as Thonny, uPyCraft, or tools like ampy.