PN532 USB Type-C Documentation

PN532 USB Type-C Documentation covers quick start steps, host setup, supported software stacks, serial access notes, and troubleshooting for the ELECHOUSE PN532 NFC USB Module (Type-C).

Quick Start

  1. Connect the module to your computer with a USB-C cable.
  2. Wait for the device to enumerate as a USB CDC / virtual serial port.
  3. Identify the port on your operating system:
    Windows: Device Manager → Ports
    Linux: /dev/ttyUSB0 or /dev/ttyACM0
    macOS: /dev/cu.*
  4. Use a compatible toolchain such as libnfc, nfcpy, or any software that can speak to a PN532 over serial / HSU.
  5. Run a basic scan / poll command to verify tag detection.

Key Technical Facts

  • Chip: NXP PN532
  • Operating frequency: 13.56 MHz
  • Host interface: USB-C, USB CDC virtual COM / serial
  • Power: 5V via USB, bus-powered
  • Typical reading distance: about 3–6 cm on common MIFARE cards, depending on tag type and placement

Supported Platforms

  • Windows
  • Linux
  • macOS
  • USB OTG-capable Android devices with appropriate software support

Supported Protocols

  • ISO 14443A: MIFARE Classic, Ultralight, DESFire
  • ISO 14443B
  • FeliCa
  • ISO 18092 / NFC-IP1 (peer-to-peer)
  • Android NFC / NDEF workflows where the host software supports PN532 serial mode

Initialization Method

  1. Plug the device into a USB-C port.
  2. Verify the system has created a serial / CDC device node.
  3. Open the port with your NFC software stack or serial-based PN532 tooling.
  4. Start with a simple read / poll workflow before building a custom desktop application.

Software and Libraries

  • libnfc
  • nfcpy
  • Any host software that supports PN532 HSU / serial framing
  • ELECHOUSE PN532 GitHub library for protocol reference and general PN532 workflows

Example Workflow

# Linux example: identify the device node
ls /dev/ttyUSB* /dev/ttyACM*

# Then open your preferred PN532-compatible toolchain
# and start polling / scanning tags.

Common Errors

  • No device appears: bad cable, charge-only cable, or host USB issue.
  • Device appears but software cannot talk to it: wrong serial parameters or wrong software backend.
  • Windows does not auto-bind a driver: install / re-bind a generic CDC serial driver.
  • Poor reading distance: card alignment, tag type, or environmental interference.

Troubleshooting

  • First confirm the board shows up as a serial device before debugging NFC.
  • Use a known-good MIFARE card for first tests.
  • Try another USB-C cable if enumeration is inconsistent.
  • If you are writing your own app, validate the serial transport separately before implementing higher-level NFC logic.

Version Differences / Positioning

  • Compared with PN532 V4, this module removes the need for MCU wiring by exposing a direct USB host connection.
  • Compared with PN7160 / PN7161, this module is simpler for desktop use but does not use the NCI 2.0 Linux / Android stack.

Update History

  • 2026-04-05: First public PN532 USB Type-C documentation page published.
  • Reference basis: ELECHOUSE product page technical description plus the standard PN532 software ecosystem.

USB Device Information

The PN532 USB Type-C module uses a USB-to-serial bridge chip (typically CH340 or CP2102). The virtual COM port is used by libnfc and nfcpy to communicate with the PN532.

OS Device Node Notes
Linux /dev/ttyUSB0 or /dev/ttyACM0 Add user to dialout group
macOS /dev/cu.usbserial-XXXX May need CH340 driver
Windows COMx (Device Manager) Install CH340 / CP2102 driver if not auto-detected
Raspberry Pi /dev/ttyUSB0 Same as Linux

libnfc Configuration

libnfc needs a configuration file to use the PN532 over UART/USB. Create or edit /etc/nfc/libnfc.conf:

# /etc/nfc/libnfc.conf
device.name = "PN532 USB"
device.connstring = "pn532_uart:/dev/ttyUSB0:115200"

Then test:

sudo apt install libnfc-bin libnfc-dev
nfc-list         # detect tags
nfc-scan-device  # confirm device is found

nfcpy Python Examples

pip install nfcpy

# Basic tag detection (serial transport)
import nfc

def on_connect(tag):
    print("Tag type:", type(tag).__name__)
    print("UID:", tag.identifier.hex().upper())
    return True

with nfc.ContactlessFrontend('tty:/dev/ttyUSB0:pn532') as clf:
    clf.connect(rdwr={'on-connect': on_connect})

# Read NDEF text record from NTAG
import nfc

def on_connect(tag):
    if tag.ndef:
        for record in tag.ndef.records:
            print("NDEF record:", record)
    return True

with nfc.ContactlessFrontend('tty:/dev/ttyUSB0:pn532') as clf:
    clf.connect(rdwr={'on-connect': on_connect})

PCSC / Smart Card Framework

On Linux, install pcscd to use the module via the PC/SC smart card API, compatible with MIFARE card management tools:

sudo apt install pcscd pcsc-tools
sudo systemctl start pcscd
pcsc_scan  # verify card reader is detected

Windows Driver Setup

  1. Connect the module via USB-C cable.
  2. Open Device Manager. Look for an unrecognized COM port device.
  3. Download and install the CH340 driver (for CH340-based boards) or CP2102 driver (for CP2102-based boards) from the chip manufacturer.
  4. After installation, a COMx port will appear.
  5. Use libnfc for Windows or nfcpy to access the module.

Related Pages

Shopping Cart