Introduction¶

CircuitPython driver for the PN532 NFC/RFID Breakout and PN532 NFC/RFID Shield

Dependencies¶

This driver depends on:

Please ensure all dependencies are available on the CircuitPython filesystem. This is easily achieved by downloading the Adafruit library and driver bundle.

Usage Example¶

Check examples/pn532_simpletest.py for usage example

Contributing¶

Contributions are welcome! Please read our Code of Conduct before contributing to help this project stay welcoming.

Building locally¶

Zip release files¶

To build this library locally you’ll need to install the circuitpython-build-tools package.

python3 -m venv .env
source .env/bin/activate
pip install circuitpython-build-tools

Once installed, make sure you are in the virtual environment:

source .env/bin/activate

Then run the build:

circuitpython-build-bundles --filename_prefix adafruit-circuitpython-pn532 --library_location .

Sphinx documentation¶

Sphinx is used to build the documentation based on rST files and comments in the code. First, install dependencies (feel free to reuse the virtual environment from above):

python3 -m venv .env
source .env/bin/activate
pip install Sphinx sphinx-rtd-theme

Now, once you have the virtual environment activated:

cd docs
sphinx-build -E -W -b html . _build/html

This will output the documentation to docs/_build/html. Open the index.html in your browser to view them. It will also (due to -W) error out on any warning like Travis will. This is a good way to locally verify it will pass.

Table of Contents¶

Simple test¶

Ensure your device works with this simple test.

examples/pn532_simpletest.py¶

"""
This example shows connecting to the PN532 with I2C (requires clock
stretching support), SPI, or UART. SPI is best, it uses the most pins but
is the most reliable and universally supported.
After initialization, try waving various 13.56MHz RFID cards over it!
"""

import board
import busio
from digitalio import DigitalInOut
#
# NOTE: pick the import that matches the interface being used
#
from adafruit_pn532.i2c import PN532_I2C
#from adafruit_pn532.spi import PN532_SPI
#from adafruit_pn532.uart import PN532_UART

# I2C connection:
i2c = busio.I2C(board.SCL, board.SDA)

# Non-hardware
#pn532 = PN532_I2C(i2c, debug=False)

# With I2C, we recommend connecting RSTPD_N (reset) to a digital pin for manual
# harware reset
reset_pin = DigitalInOut(board.D6)
# On Raspberry Pi, you must also connect a pin to P32 "H_Request" for hardware
# wakeup! this means we don't need to do the I2C clock-stretch thing
req_pin = DigitalInOut(board.D12)
pn532 = PN532_I2C(i2c, debug=False, reset=reset_pin, req=req_pin)

# SPI connection:
#spi = busio.SPI(board.SCK, board.MOSI, board.MISO)
#cs_pin = DigitalInOut(board.D5)
#pn532 = PN532_SPI(spi, cs_pin, debug=False)

# UART connection
#uart = busio.UART(board.TX, board.RX, baudrate=115200, timeout=100)
#pn532 = PN532_UART(uart, debug=False)

ic, ver, rev, support = pn532.get_firmware_version()
print('Found PN532 with firmware version: {0}.{1}'.format(ver, rev))

# Configure PN532 to communicate with MiFare cards
pn532.SAM_configuration()

print('Waiting for RFID/NFC card...')
while True:
    # Check if a card is available to read
    uid = pn532.read_passive_target(timeout=0.5)
    print('.', end="", flush=True)
    # Try again if no card is available.
    if uid is None:
        continue
    print('Found card with UID:', [hex(i) for i in uid])

`adafruit_pn532`¶

This module will let you communicate with a PN532 RFID/NFC shield or breakout using I2C, SPI or UART.

Author(s): Original Raspberry Pi code by Tony DiCola, CircuitPython by ladyada

Implementation Notes¶

Hardware:

Adafruit PN532 Breakout
Adafruit PN532 Shield

Software and Dependencies:

Adafruit CircuitPython firmware for the supported boards: https://github.com/adafruit/circuitpython/releases
Adafruit’s Bus Device library: https://github.com/adafruit/Adafruit_CircuitPython_BusDevice

exception adafruit_pn532.adafruit_pn532.BusyError¶: Base class for exceptions in this module.

class adafruit_pn532.adafruit_pn532.PN532(*, debug=False, reset=None)¶

PN532 driver base, must be extended for I2C/SPI/UART interfacing

SAM_configuration()¶: Configure the PN532 to read MiFare cards.

call_function(command, response_length=0, params=[], timeout=1)¶: Send specified command to the PN532 and expect up to response_length bytes back in a response. Note that less than the expected bytes might be returned! Params can optionally specify an array of bytes to send as parameters to the function call. Will wait up to timeout seconds for a response and return a bytearray of response bytes, or None if no response is available within the timeout.

get_firmware_version()¶: Call PN532 GetFirmwareVersion function and return a tuple with the IC, Ver, Rev, and Support values.

mifare_classic_authenticate_block(uid, block_number, key_number, key)¶: Authenticate specified block number for a MiFare classic card. Uid should be a byte array with the UID of the card, block number should be the block to authenticate, key number should be the key type (like MIFARE_CMD_AUTH_A or MIFARE_CMD_AUTH_B), and key should be a byte array with the key data. Returns True if the block was authenticated, or False if not authenticated.

mifare_classic_read_block(block_number)¶: Read a block of data from the card. Block number should be the block to read. If the block is successfully read a bytearray of length 16 with data starting at the specified block will be returned. If the block is not read then None will be returned.

mifare_classic_write_block(block_number, data)¶: Write a block of data to the card. Block number should be the block to write and data should be a byte array of length 16 with the data to write. If the data is successfully written then True is returned, otherwise False is returned.

ntag2xx_read_block(block_number)¶: Read a block of data from the card. Block number should be the block to read. If the block is successfully read a bytearray of length 16 with data starting at the specified block will be returned. If the block is not read then None will be returned.

ntag2xx_write_block(block_number, data)¶: Write a block of data to the card. Block number should be the block to write and data should be a byte array of length 4 with the data to write. If the data is successfully written then True is returned, otherwise False is returned.

read_passive_target(card_baud=<sphinx.ext.autodoc.importer._MockObject object>, timeout=1)¶: Wait for a MiFare card to be available and return its UID when found. Will wait up to timeout seconds and return None if no card is found, otherwise a bytearray with the UID of the found card is returned.

`adafruit_pn532.i2c`¶

This module will let you communicate with a PN532 RFID/NFC shield or breakout using I2C.

Author(s): Original Raspberry Pi code by Tony DiCola, CircuitPython by ladyada,

refactor by Carter Nelson

class adafruit_pn532.i2c.PN532_I2C(i2c, *, irq=None, reset=None, req=None, debug=False)¶: Driver for the PN532 connected over I2C.

`adafruit_pn532.spi`¶

This module will let you communicate with a PN532 RFID/NFC shield or breakout using SPI.

Author(s): Original Raspberry Pi code by Tony DiCola, CircuitPython by ladyada,

refactor by Carter Nelson

class adafruit_pn532.spi.PN532_SPI(spi, cs_pin, *, irq=None, reset=None, debug=False)¶: Driver for the PN532 connected over SPI. Pass in a hardware or bitbang SPI device & chip select digitalInOut pin. Optional IRQ pin (not used), reset pin and debugging output.

adafruit_pn532.spi.reverse_bit(num)¶: Turn an LSB byte to an MSB byte, and vice versa. Used for SPI as it is LSB for the PN532, but 99% of SPI implementations are MSB only!

`adafruit_pn532.uart`¶

This module will let you communicate with a PN532 RFID/NFC shield or breakout using UART.

Author(s): Original Raspberry Pi code by Tony DiCola, CircuitPython by ladyada,

refactor by Carter Nelson

class adafruit_pn532.uart.PN532_UART(uart, *, irq=None, reset=None, debug=False)¶: Driver for the PN532 connected over Serial UART