Project Files of PN532 NFC Library for Proteus V1.1 (SPI + I2C + Arduino)

PN532 NFC RFID MODULE (V3) LIBRARY FOR PROTEUS - V1.1
Designed by The Engineering Projects
www.TheEngineeringProjects.com

IMPORTANT LINKS
Article (read it first - pictures, step by step, every feature explained):
  https://www.theengineeringprojects.com/2026/09/pn532-nfc-proteus-library.html
Report a bug or suggest a feature (our forum):
  https://www.theengineeringprojects.com/forum/category/pn532-proteus-library
The demo uses our TEP Serial Monitor Advance (included) instead of Proteus's
Virtual Terminal - its own article:
  https://www.theengineeringprojects.com/2026/10/serial-monitor-advance-proteus-library.html
Support us (the libraries are free):
  https://www.theengineeringprojects.com/donate

FILE STRUCTURE
PN532-TEP-v1.1/
|-- Proteus Library Files/
|   |-- ArduinoV3TEP.IDX                              0.8 KB   its index -> LIBRARY folder
|   |-- ArduinoV3TEP.LIB                             95.6 KB   TEP Arduino UNO (demo) -> LIBRARY folder
|   |-- TEPPN532.LIB                                109.9 KB   PN532 Simple + Advance (2 devices) -> LIBRARY folder
|   |-- TEPSERIALMON.LIB                             11.1 KB   TEP Serial Monitor Advance -> LIBRARY folder
|-- Proteus Model Files/
|   |-- TEPPN532.DLL                                365.0 KB   PN532 model -> MODELS folder
|   |-- TEPSERIALMON.DLL                            978.0 KB   Serial Monitor model -> MODELS folder
|-- Proteus Simulation/
|   |-- PN532_I2C_Demo.hex                           52.0 KB   UNO 2 (I2C demo v1.1)
|   |-- PN532_SPI_Demo.hex                           52.4 KB   UNO 1 (SPI demo v1.1)
|   |-- PN532-ArduinoUnoV3.pdsprj                    26.4 KB   demo: UNO 1 + PN532 Simple (SPI), UNO 2 + Advance (I2C)
|   |-- TEPPN532.DLL                                365.0 KB   copy of the model so the demo runs as is
|   |-- TEPSERIALMON.DLL                            978.0 KB   copy of the monitor model
|-- Arduino Code/
|   |-- PN532_I2C_Demo/PN532_I2C_Demo.ino            17.2 KB   I2C sketch (source of its .hex)
|   |-- PN532_SPI_Demo/PN532_SPI_Demo.ino            17.2 KB   SPI sketch (source of its .hex)
|   |-- libraries/Adafruit_PN532/                   146.5 KB   Adafruit PN532 1.3.4 (BSD, license.txt), 18 files
|   |-- libraries/Adafruit_BusIO/                    53.6 KB   Adafruit BusIO 1.17.4 (MIT, LICENSE), 14 files
|-- README.txt                                      ~36.0 KB   this file
Total: 3.23 MB (unzipped). The C++ source code of the model is not included.

WHAT IS IT?
A simulation model of the NXP PN532 NFC controller on the common red "PN532 NFC
RFID module V3" board for Proteus 8. Your Arduino talks to it exactly as to the
real one - over SPI, I2C (address 0x24) or HSU (UART 115200) - and the popular
Adafruit PN532 library runs unmodified: begin, getFirmwareVersion, SAMConfig,
setPassiveActivationRetries, readPassiveTargetID, the IRQ detection
(startPassiveTargetIDDetection / readDetectedPassiveTargetID),
mifareclassic_AuthenticateBlock / ReadDataBlock / WriteDataBlock / FormatNDEF /
WriteNDEFURI, ntag2xx_ReadPage / WritePage / WriteNDEFURI, inListPassiveTarget +
inDataExchange, readGPIO / writeGPIO. The model has the PN532's frame protocol
(ACK, NACK, error frames, extended frames), its timing, the IRQ pin and RSTPDN,
and the cards answer like real ISO 14443A cards: MIFARE Classic 1K and 4K (keys
and access bits in every sector trailer), MIFARE Ultralight and NTAG213 / 215 /
216 (NDEF). You place cards on the reader with a click. The part looks like the
red V3 board: the big PCB antenna coil, the PN532 with its 27.12 MHz crystal,
the mode switch with the mode table beside it, the two pin headers and the PWR
LED; while the simulation runs the coil glows cyan while the RF field is on and
green while a card answers, the waves above it follow, the card on the reader
is drawn on the antenna with its number, UID and state, and the mode switch +
the table show the interface your Arduino uses (SPI / I2C / HSU). Beside PWR
sit a green CARD LED and an amber IRQ LED - the CARD LED and the IRQ LED (TEP
additions; the real board has only the power LED) flash when a card answers and
while the IRQ pin is LOW (a response is ready).

TWO DEVICES IN ONE LIBRARY (search "PN532" in Pick Devices):
  PN532 Simple    device PN532TEP     "PN532 NFC RFID Module - Simple"
                  On-Sheet Panel: a card panel on the schematic next to the
                  reader - the reader's state, CARD 1 .. CARD 4 (click one to
                  hold it on the reader), REMOVE CARD and the last commands the
                  Arduino sent (decoded: 4A InListPassiveTarget -> DE AD BE EF,
                  40 MIFARE READ block 4 -> 16 bytes ...). The red X in the
                  panel's header closes it, the PANEL button on the board opens
                  it again. Your v1.0 designs keep working with this device.
  PN532 Advance   device PN532ADVTEP  "PN532 NFC RFID Module - Advance"
                  Pop-Up Panel: only the reader board on the schematic; at Run a
                  TEP pop-up window opens - the same look as the TEP Serial
                  Monitor (move it by its header, resize it, minimise it). The
                  tabs Cards and Test sit in the header; the gear and ? icons
                  open Settings and Help; the palette icon switches the theme:
                    Cards     the card wallet: the READER card (field on / off,
                              the card in the field and its state, cards found
                              and the last UID, the link: SPI / I2C / HSU with
                              its measured clock), the four cards with Tap (0.5
                              s on the reader) and Hold (until removed), Remove
                              the card, and an editor: the card's type (1K, 4K,
                              UL, 213, 215, 216), its UID typed with a hex keypad
                              (or Random), Apply; its memory block by block
                              (Classic) or 4 pages at a time (Ultralight / NTAG)
                              with the keys and access bits of the sector (or
                              the NDEF message decoded), presets (Text, Zeros,
                              Value 100) and Write
                    Test      four tools measured on the model with your
                              sketch: Read test, Card types, Authentication,
                              Command / frame check (see THE TEST TOOLS below)
                    Settings  theme (TEP Dark / Light), text size, open at Run,
                              window size - remembered for your Windows user
                    Help      Help & Support like the TEP Serial Monitor: report
                              a bug, suggest a feature, article, user guide,
                              updates, donate, website, forum; Copy diagnostics
                              (reader, link, frames, timing, cards, test
                              results) for a bug report
                  The OPEN PANEL button on the board opens the window again
                  after you close it.
Both devices use the same model (TEPPN532.DLL) and the same properties.

NEW IN V1.1
* Two devices: PN532 Simple (card panel on the sheet, close / open) and PN532
  Advance (pop-up window with the card wallet and editor, four test tools,
  settings and help) - see above.
* Board: the real red V3 board's look - nearly square, the PCB antenna coil is
  the big part it is on the real module, the mode switch with its mode table
  (HSU 0 0, I2C 1 0, SPI 0 1), the two headers - with an antenna glow (cyan =
  field on, green = a card answers), waves above the antenna, the card drawn on
  the antenna, the switch knobs and the table row of the interface in use, its
  clock under the table, a PANEL / OPEN PANEL button and a SIMPLE / ADVANCE
  badge. LEDs: PWR (red), CARD (green) and IRQ (amber) - the CARD LED and the
  IRQ LED are TEP additions (the real board has only the power LED): CARD lights
  for 0.35 s (simulation time) after every card answer, IRQ while the IRQ pin is
  LOW.
* Model - timing: every card exchange takes its air time at 106 kbit/s (ISO
  14443-3) plus the card's own time and the PN532's firmware time:
  InListPassiveTarget finds a card with a 4-byte UID in 2.8 ms, one with a
  7-byte UID (two cascade levels) in 4.7 ms; MIFARE AUTH 2.35 ms, READ 2.4 ms, a
  Classic write + 2.5 ms, an NTAG write + 4.1 ms. A target that does not answer
  (a wrong key, a removed card) ends after the PN532's own timeout -
  RFConfiguration item 2, default 51.2 ms - with error 01 / 14, as on real
  hardware (v1.0: 25 ms). Without a card InListPassiveTarget polls every 2 ms:
  MxRtyPassiveActivation 0x10 = 17 tries = 34 ms, 0xFF = until a card comes; a
  card that arrives is found at the next try. InAutoPoll uses its Period x 150
  ms. The ACK is ready 0.3 ms after the frame.
* Model - the RF field is off after power-up and reset and switched on by the
  first command that needs it (RFConfiguration item 1 and PowerDown switch it
  off); GetGeneralStatus reports it.
* Model - cards: MIFARE Classic 4K (SEL_RES 18, 40 sectors), Ultralight (16
  pages) and NTAG215 / NTAG216 (135 / 231 pages, GET_VERSION through
  InCommunicateThru, PWD_AUTH, FAST_READ) besides Classic 1K and NTAG213;
  properties TYPEn choose (AUTO = from the UID length, as in v1.0). The keys and
  access bits live in every sector trailer: KEYA / KEYB set them at the start, a
  sketch that writes a trailer changes that sector's keys, the access-condition
  table of the MIFARE Classic data sheet is enforced (a readable key B
  authenticates but every access gets error 14), invalid access bits block the
  sector, INC / DEC check the value-block format; Ultralight / NTAG page 3 and
  the lock bytes are OR-written.
* Model - HSU: property MODE = HSU makes the module a UART device (SCL = RXD,
  SDA = TXD, 115200 8N1, SetSerialBaudRate supported); MODE = SPI / I2C keeps
  only that interface; MODE = AUTO (default) = SPI and I2C both live, as v1.0.
* Model - logs: every command (decoded) with its times (frame in, ACK ready /
  read, response ready / read) and every host transaction (SPI DW / SR / DR, I2C
  write / read / RDY polls / NACK, HSU frames) - the Simple panel's last
  commands, the Command / frame check and Copy diagnostics show them.
* The demo: ONE project with two UNOs - UNO 1 with PN532 Simple on SPI, UNO 2
  with PN532 Advance on I2C - each with the TEP Serial Monitor Advance instead
  of the Virtual Terminal (U3 = UNO 1, U4 = UNO 2, quick buttons) and an access
  LED on A0.
* The demo sketches (v1.1) keep every v1.0 line and add: the access list with
  the LED (3 s on ACCESS GRANTED), ADD / DEL (with or without a UID), STATUS,
  READ n, WRITE n text, DUMP, NDEF url, KEY A / KEY B, HELP; a 4K card prints
  "MIFARE Classic 4K", an NTAG / Ultralight its type from the capability
  container.
* Version 1.1 everywhere; the C++ source code is no longer included (and
  neither is the Arduino AVR core archive - its GitHub link is below).

TEST STATUS
v1.1 was tested in Proteus 8.5 SP0 (7 Oct 2026) with this package's demo: both
Serial Monitors (9600) and the Advance pop-up open at Run (no system caption
row); U3 prints "TEP PN532 NFC Demo v1.1 (SPI)", U4 "... (I2C)", both "Found
chip PN532, firmware 1.6"; the boards show the SPI row on U1 and the I2C row on
U2, the antennas cyan. U1 (Simple, SPI): CARD 1 (UID DE AD BE EF, MIFARE Classic
1K, block 4, "TEP PN532 CARD 1", ACCESS GRANTED; the antenna and the CARD LED
green, the card drawn on the antenna), CARD 3 (NTAG213 (144 bytes), the NDEF URI,
GRANTED), CARD 2 DENIED -> ADD ("Added 12 34 56 78 (3 allowed)") -> CARD 2
GRANTED, CARD 4 ("NDEF: empty message", DENIED), REMOVE CARD ("Card removed"),
STATUS ("Status: 5 cards read, 3 allowed, key A, LED off, PN532 firmware 1.6,
SPI"), the red X and PANEL. U2 (Advance, I2C): Hold CARD 3 (the NTAG213 read and
the NDEF URI, GRANTED), close the pop-up and OPEN PANEL; Test > Read test (card
1, 0.5 s, 5 runs: 5 / 5, found 3.6 - 4.8 ms after the tap (one tap 16.9 ms), the
UID in the Arduino after 12.6 ms on average, the block read 24.5 ms, the next
poll 112 ms), Card types (6 / 6 found, 6 / 6 data read, found after 6.5 ms on
average, 88 commands), Authentication (Keys as set 3 / 3: AUTH 2.35 ms, READ 16
bytes; Key A changed 0 / 3: "14 - wrong key" after 53.10 ms), Frames ("I2C at
0x24 - 100 kHz (MODE AUTO)", ACK ready 0.30 ms, InListPassiveTarget answered in
2.80 ms on average, MxRtyPassiveActivation 16 = 17 tries x 2 ms, timeout 51.2
ms), Settings, and Help (all 8 cards with the live links).
Not run in Proteus: HSU was tested on a PC only (no demo uses it - MODE = HSU
needs a Mega's Serial1); a v1.0 design (the v1.0 symbol) was not re-run in
Proteus with v1.1 (PC adapter test only); the Authentication tool's Key B only
set-up was tested on a PC only.
PC tests:
  1781 automatic checks on a PC, 0 failed: 116 with the unmodified Adafruit PN532
  library driving the chip model over hardware SPI, software SPI, I2C and HSU
  (the 48 of v1.0, unchanged, plus 68 for v1.1: the timing, the field, the logs,
  the card types, keys and access bits, value blocks, NTAG writes and
  GET_VERSION, taps, InAutoPoll, frames, HSU); 58 + 58 with the real v1.1 demo
  sketches over SPI and over I2C (every v1.0 output line, the LED, every Serial
  Monitor command, the card types, a wrong key, the three test tools); 110 on
  the complete Proteus model (the 24 of v1.0 on a design with the v1.0 symbol
  plus both devices, the panel's red X / PANEL, the pop-up and its Cards page,
  the board's LEDs / antenna glow / card / mode switch, the MODE property with
  HSU bits through the pins, the properties, RSTPDN, power, the tools through
  the pop-up); 1439 on the rendered boards and pop-up windows (every page fits
  in TEP Dark and Light, at Large text and 150 % DPI; every tool's hint lines
  fit the window; every header state fits).
v1.0 (30 Sep 2026): both v1.0 demos (SPI and I2C) were run in Proteus 8.5 - card
  UID, MIFARE block 4 text, NTAG NDEF URL, "Card removed", empty NDEF.

INSTALLATION (about 2 minutes)
1. Close Proteus. Extract the WHOLE ZIP to a normal folder (e.g. Desktop).
2. Copy everything in "Proteus Library Files" (TEPPN532.LIB with both devices,
   TEPSERIALMON.LIB and the TEP Arduino UNO V3 library ArduinoV3TEP.LIB / .IDX
   used by the demo) to the LIBRARY folder of Proteus, for example:
     C:\Program Files (x86)\Labcenter Electronics\Proteus 8 Professional\LIBRARY
   (on some PCs: C:\ProgramData\Labcenter Electronics\Proteus 8 Professional\
   LIBRARY - use the folder that already holds Proteus's own .LIB files).
3. Copy TEPPN532.DLL and TEPSERIALMON.DLL from "Proteus Model Files" to the
   MODELS folder (...\Proteus 8 Professional\MODELS).
4. Updating from v1.0: replace TEPPN532.LIB and TEPPN532.DLL, and delete
   TEPPN532.IDX if there is one in the LIBRARY folder. A v1.0 design keeps its
   v1.0 symbol: it runs with the new model and shows the v1.0 panel (without the
   v1.1 board parts and the red X) - re-pick the part to get the v1.1 symbol.
5. Start Proteus. In Pick Devices (P) search "PN532": you get the Simple and the
   Advance device (category Peripherals > Wireless, as in v1.0).

RUN THE DEMO
"Proteus Simulation\PN532-ArduinoUnoV3.pdsprj" - keep the two .hex files and
the two DLLs beside the project.
  UNO 1 (ARD1): PN532 Simple (U1) on SPI, Serial Monitor U3, PN532_SPI_Demo.hex.
  UNO 2 (ARD2): PN532 Advance (U2) on I2C, Serial Monitor U4, PN532_I2C_Demo.hex.
  An LED (D1 / D2) with 220 ohm on A0 of each UNO: the access LED.
  1. Press Run. Both monitor windows open (9600 baud) and so does U2's pop-up.
     U3 shows "TEP PN532 NFC Demo v1.1 (SPI)", U4 "... (I2C)", then "Found chip
     PN532, firmware 1.6", "Place a card on the reader", the allowed cards and
     the command list. The board's switch and table show SPI on U1, I2C on U2;
     the antennas turn cyan as soon as the sketches poll for cards.
  2. U1: click CARD 1 on the panel beside the reader - U3 prints "Card UID: DE
     AD BE EF (4 bytes)", "MIFARE Classic 1K", "Block 4: ..." and "Text   : TEP
     PN532 CARD 1", then "-> ACCESS GRANTED"; LED D1 lights for 3 s; the antenna
     and the CARD LED flash green, the card on the antenna says SELECTED.
     CARD 3 (NTAG213) prints the NDEF URI https://www.theengineeringprojects.com
     and is allowed; CARD 2 and CARD 4 are denied. REMOVE CARD: "Card removed".
     Close the panel with its red X and open it with PANEL on the board.
  3. U3 / U4 quick buttons: STATUS, ADD (allow the last card read - read CARD 2,
     ADD, read it again: granted), DEL (remove it again), DUMP (the memory of
     the card on the reader). Type HELP, READ 4, WRITE 5 Hello, NDEF
     https://example.com (with an NTAG card on the reader), KEY B, ADD
     04A1B2C3D4E580.
  4. U2 (Advance): Cards page - Tap / Hold the cards and watch the READER card.
     (U4's lines can come a few seconds after the click: I2C is slower than
     SPI and Proteus runs the two UNOs slower than real time - the Read test
     shows the simulated times.)
     Click CARD 4 to edit it: choose 216, Apply, then Hold it - the sketch prints
     "Type   : NTAG216 (872 bytes)". Type a new UID with the keypad (Apply), or
     step to a block / page, choose Text and Write it. Test page:
       Read test: card 1, 0.5 s, 5 runs - each tap is found within one poll
         (about 4 ms), the UID is in the Arduino a few ms later, AUTH + READ
         follow, and the next poll about 100 ms later (the sketch's prints).
       Card types: the six test cards and what the sketch does with each.
       Authentication: Keys as set / Key A changed (error 14 after the 51.2 ms
         timeout) / Key B only (READ refused); then type KEY B on U4 and run
         Key B only again.
       Frames: the commands your sketch sends, decoded, with their times.
  5. Close U2's window and open it again with OPEN PANEL on the board.
Closed a monitor window? Click OPEN MONITOR on the monitor part.

WIRING (as in the v1.0 demos)
SPI (UNO 1): VCC -> supply, GND -> GND, SCK -> D13, MISO -> D12, MOSI -> D11,
  SS -> D10; IRQ and RST not connected.
  In the sketch: Adafruit_PN532 nfc(10);  nfc.begin();  Serial 9600.
I2C (UNO 2): VCC -> supply, GND -> GND, SCL -> A5, SDA -> A4 (address 0x24);
  IRQ -> D2 and RSTPDN -> D3 are optional (the library polls the ready byte).
  In the sketch: Adafruit_PN532 nfc(2, 3);  nfc.begin();  Serial 9600.
HSU (property MODE = HSU): SCL is RXD (from the host's TX), SDA is TXD (to the
  host's RX), 115200 8N1. The UNO's only hardware serial port is used by the
  Serial Monitor, so use an Arduino Mega (Serial1) for HSU: Adafruit_PN532
  nfc(resetPin, &Serial1). Note: the Adafruit library 1.3.4 reads a fixed
  number of bytes on HSU, more than the PN532 sends for some answers, so some
  calls wait for the 1 s Stream timeout, and it does not read the answer of
  setPassiveActivationRetries (empty Serial1 after it) - the model reproduces
  this real-hardware behaviour.
  The access LED + 220 ohm from A0 to GND on both UNOs.
  Serial Monitor RXD <- Arduino D1 (TX), Serial Monitor TXD -> Arduino D0 (RX),
  Serial Monitor GND -> ground. RXD2 is not needed: SPI and I2C have no serial
  line between the reader and the Arduino to watch.
Pin order in Proteus: VCC GND SCL SDA SCK MISO MOSI SS IRQ RST (v1.0). On the
real board the 4-pin header reads GND VCC SDA SCL (HSU names TXD / RXD on the
back) and the 8-pin header SCK MISO MOSI SS VCC GND IRQ RSTO - wire by the names.
REAL HARDWARE:
 * Supply: VCC 3.3 V or 5 V (the V3 board has its own 3.3 V regulator).
 * Logic levels: the V3 board has an on-board level shifter for I2C and HSU (5 V
   TTL), but SPI is 3.3 V TTL: from a 5 V UNO use a level shifter (or 1 k / 2 k
   dividers on SCK, MOSI and SS). MISO (3.3 V) is read correctly by the UNO.
 * The mode switch (two slide switches, ON = 1): HSU 1 OFF 2 OFF, I2C 1 ON 2 OFF,
   SPI 1 OFF 2 ON - set it BEFORE power-up (the PN532 reads it at reset). In the
   simulation the property MODE plays the switch (AUTO = SPI and I2C both).
 * Range: 5 - 7 cm with the board's PCB antenna (Elechouse data); metal near the
   antenna detunes it. The simulation has no distance - a card is in the field
   or not.
 * IRQ (P70_IRQ) is LOW while a response is ready; RSTO / RSTPDN low = reset /
   power-down.

THE CARDS
Default cards (properties UID1..UID4 and TYPE1..TYPE4):
  CARD 1  DE AD BE EF           MIFARE Classic 1K   allowed in the demo
  CARD 2  12 34 56 78           MIFARE Classic 1K   denied (ADD allows it)
  CARD 3  04 11 22 33 44 55 66  NTAG213 (NDEF URI)  allowed in the demo
  CARD 4  04 A1 B2 C3 D4 E5 80  NTAG213 (empty)     denied
MIFARE Classic 1K: 16 sectors of 4 blocks; block 0 holds the UID, BCC, SAK and
ATQA (read-only), block 4 the demo text "TEP PN532 CARD n", every sector trailer
key A (KEYA), the transport access bits FF 07 80 69 and key B (KEYB).
MIFARE Classic 4K: the same, 32 sectors of 4 blocks + 8 sectors of 16 blocks.
MIFARE Ultralight: 7-byte UID, 16 pages of 4 bytes, no keys.
NTAG213 / 215 / 216: 7-byte UID, 45 / 135 / 231 pages, the capability container
E1 10 12 / 3E / 6D 00, an NDEF URI record "https://www.theengineeringprojects.com"
(cards 1 and 3) or an empty NDEF message (cards 2 and 4); GET_VERSION through
InCommunicateThru, PWD_AUTH (password FF FF FF FF), FAST_READ. The library's
inDataExchange cannot tell an NTAG213 from an Ultralight - the demo reads the
capability container.
Writes stay while the simulation runs; every new run starts with fresh cards.

THE TEST TOOLS (PN532 Advance, Test tab) - what they really measure
Every tool runs on the live model with your sketch. A tool only places cards in
the field and reads the PN532's own log - it never talks to your Arduino - so
every time is what your sketch's frames and the card really did, measured with
the simulation clock. Each tool shows one "Good for:" line and one line on how
it measures.
  Read test       Good for: seeing how fast your loop() notices a card and how
                  long it needs to read it. Taps card 1-4 on the reader 3, 5 or
                  10 times (0.2, 0.5 or 1 s in the field, 1 s apart) and times
                  each step from the tap: the PN532 found it (InListPassiveTarget
                  answered), the UID is in your Arduino (the response read), the
                  first AUTH, the first READ (ok / error) and your sketch's next
                  poll. In Proteus with the demo's U2 (I2C, 100 kHz), card 1,
                  0.5 s taps x 5: 5 / 5 found 3.6 - 4.8 ms after the tap (the
                  next 2 ms try + 2.8 ms; one tap 16.9 ms - a tap that lands
                  while the sketch is not polling waits for its next
                  InListPassiveTarget), the UID in the Arduino after 12.6 ms on
                  average, the block read 24.5 ms, the next poll 112 ms (the
                  Serial prints at 9600 baud).
  Card types      Good for: checking that your sketch reads every card type - 4-
                  and 7-byte UIDs, Classic and NTAG. Holds a Classic 1K, a
                  Classic 4K, an Ultralight, an NTAG213, 215 and 216 test card 1
                  s each and lists SENS_RES / SEL_RES, the UID size and every
                  command your sketch sent to the card with the answer (e.g.
                  "InListPassiveTarget (4 B UID), AUTH A 4 ok, READ 4 ok" for the
                  1K; "InListPassiveTarget (7 B UID), READ 3..15 (13 x, 13 ok)"
                  for the Ultralight / NTAG cards with the demo sketch - the
                  capability container, then the NDEF pages).
  Authentication  Good for: seeing which key your sketch really sends and what a
                  card with other keys answers. A Classic 1K test card in three
                  set-ups: Keys as set (KEYA / KEYB, transport access bits), Key
                  A changed (A0 A1 A2 A3 A4 A5 on the card), Key B only (access
                  bits 0F 00 FF: the data blocks need key B, key B is secret).
                  Per run: the key your sketch sent (A or B and its six bytes -
…