Initial gh-pages firmware hosting

1 files changed, 1832 insertions, 0 deletions

diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit PN532/Adafruit_PN532.cpp b/.pio/libdeps/esp32-s3-n16r8/Adafruit PN532/Adafruit_PN532.cpp
new file mode 100644
index 0000000..0a547b7
--- /dev/null
+++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit PN532/Adafruit_PN532.cpp
@@ -0,0 +1,1832 @@
+/**************************************************************************/
+/*!
+    @file Adafruit_PN532.cpp
+
+    @section intro_sec Introduction
+
+    Driver for NXP's PN532 NFC/13.56MHz RFID Transceiver
+
+    This is a library for the Adafruit PN532 NFC/RFID breakout boards
+    This library works with the Adafruit NFC breakout
+    ----> https://www.adafruit.com/products/364
+
+    Check out the links above for our tutorials and wiring diagrams
+    These chips use SPI or I2C to communicate.
+
+    Adafruit invests time and resources providing this open source code,
+    please support Adafruit and open-source hardware by purchasing
+    products from Adafruit!
+
+    @section author Author
+
+    Adafruit Industries
+
+    @section license License
+
+    BSD (see license.txt)
+
+    @section  HISTORY
+
+    v2.2 - Added startPassiveTargetIDDetection() to start card detection and
+            readDetectedPassiveTargetID() to read it, useful when using the
+            IRQ pin.
+
+    v2.1 - Added NTAG2xx helper functions
+
+    v2.0 - Refactored to add I2C support from Adafruit_NFCShield_I2C library.
+
+    v1.4 - Added setPassiveActivationRetries()
+
+    v1.2 - Added writeGPIO()
+         - Added readGPIO()
+
+    v1.1 - Changed readPassiveTargetID() to handle multiple UID sizes
+         - Added the following helper functions for text display
+             static void PrintHex(const byte * data, const uint32_t numBytes)
+             static void PrintHexChar(const byte * pbtData, const uint32_t
+   numBytes)
+         - Added the following Mifare Classic functions:
+             bool mifareclassic_IsFirstBlock (uint32_t uiBlock)
+             bool mifareclassic_IsTrailerBlock (uint32_t uiBlock)
+             uint8_t mifareclassic_AuthenticateBlock (uint8_t * uid, uint8_t
+   uidLen, uint32_t blockNumber, uint8_t keyNumber, uint8_t * keyData) uint8_t
+   mifareclassic_ReadDataBlock (uint8_t blockNumber, uint8_t * data) uint8_t
+   mifareclassic_WriteDataBlock (uint8_t blockNumber, uint8_t * data)
+         - Added the following Mifare Ultalight functions:
+             uint8_t mifareultralight_ReadPage (uint8_t page, uint8_t * buffer)
+*/
+/**************************************************************************/
+
+#include "Adafruit_PN532.h"
+
+byte pn532ack[] = {0x00, 0x00, 0xFF,
+                   0x00, 0xFF, 0x00}; ///< ACK message from PN532
+byte pn532response_firmwarevers[] = {
+    0x00, 0x00, 0xFF,
+    0x06, 0xFA, 0xD5}; ///< Expected firmware version message from PN532
+
+// Uncomment these lines to enable debug output for PN532(SPI) and/or MIFARE
+// related code
+
+// #define PN532DEBUG
+// #define MIFAREDEBUG
+
+// If using Native Port on Arduino Zero or Due define as SerialUSB
+#define PN532DEBUGPRINT Serial ///< Fixed name for debug Serial instance
+// #define PN532DEBUGPRINT SerialUSB ///< Fixed name for debug Serial instance
+
+#define PN532_PACKBUFFSIZ 64                ///< Packet buffer size in bytes
+byte pn532_packetbuffer[PN532_PACKBUFFSIZ]; ///< Packet buffer used in various
+                                            ///< transactions
+
+/**************************************************************************/
+/*!
+    @brief  Instantiates a new PN532 class using software SPI.
+
+    @param  clk       SPI clock pin (SCK)
+    @param  miso      SPI MISO pin
+    @param  mosi      SPI MOSI pin
+    @param  ss        SPI chip select pin (CS/SSEL)
+*/
+/**************************************************************************/
+Adafruit_PN532::Adafruit_PN532(uint8_t clk, uint8_t miso, uint8_t mosi,
+                               uint8_t ss) {
+    _cs = ss;
+    spi_dev = new Adafruit_SPIDevice(ss, clk, miso, mosi, 1000000,
+                                     SPI_BITORDER_LSBFIRST, SPI_MODE0);
+}
+
+/**************************************************************************/
+/*!
+    @brief  Instantiates a new PN532 class using I2C.
+
+    @param  irq       Location of the IRQ pin
+    @param  reset     Location of the RSTPD_N pin
+    @param  theWire   pointer to I2C bus to use
+*/
+/**************************************************************************/
+Adafruit_PN532::Adafruit_PN532(uint8_t irq, uint8_t reset, TwoWire *theWire)
+    : _irq(irq), _reset(reset) {
+    pinMode(_irq, INPUT);
+    pinMode(_reset, OUTPUT);
+    i2c_dev = new Adafruit_I2CDevice(PN532_I2C_ADDRESS, theWire);
+}
+
+/**************************************************************************/
+/*!
+    @brief  Instantiates a new PN532 class using hardware SPI.
+
+    @param  ss        SPI chip select pin (CS/SSEL)
+    @param  theSPI    pointer to the SPI bus to use
+*/
+/**************************************************************************/
+Adafruit_PN532::Adafruit_PN532(uint8_t ss, SPIClass *theSPI) {
+    _cs = ss;
+    spi_dev = new Adafruit_SPIDevice(ss, 1000000, SPI_BITORDER_LSBFIRST,
+                                     SPI_MODE0, theSPI);
+}
+
+/**************************************************************************/
+/*!
+    @brief  Instantiates a new PN532 class using hardware UART (HSU).
+
+    @param  reset     Location of the RSTPD_N pin
+    @param  theSer    pointer to HardWare Serial bus to use
+*/
+/**************************************************************************/
+Adafruit_PN532::Adafruit_PN532(uint8_t reset, HardwareSerial *theSer)
+    : _reset(reset) {
+    pinMode(_reset, OUTPUT);
+    ser_dev = theSer;
+}
+
+/**************************************************************************/
+/*!
+    @brief  Setups the HW
+
+    @returns  true if successful, otherwise false
+*/
+/**************************************************************************/
+bool Adafruit_PN532::begin() {
+    if (spi_dev) {
+        // SPI initialization
+        if (!spi_dev->begin()) {
+            return false;
+        }
+    } else if (i2c_dev) {
+        // I2C initialization
+        // PN532 will fail address check since its asleep, so suppress
+        if (!i2c_dev->begin(false)) {
+            return false;
+        }
+    } else if (ser_dev) {
+        ser_dev->begin(115200);
+        // clear out anything in read buffer
+        while (ser_dev->available())
+            ser_dev->read();
+    } else {
+        // no interface specified
+        return false;
+    }
+    reset(); // HW reset - put in known state
+    delay(10);
+    wakeup(); // hey! wakeup!
+    return true;
+}
+
+/**************************************************************************/
+/*!
+    @brief  Perform a hardware reset. Requires reset pin to have been provided.
+*/
+/**************************************************************************/
+void Adafruit_PN532::reset(void) {
+    // see Datasheet p.209, Fig.48 for timings
+    if (_reset != -1) {
+        digitalWrite(_reset, LOW);
+        delay(1); // min 20ns
+        digitalWrite(_reset, HIGH);
+        delay(2); // max 2ms
+    }
+}
+
+/**************************************************************************/
+/*!
+    @brief  Wakeup from LowVbat mode into Normal Mode.
+*/
+/**************************************************************************/
+void Adafruit_PN532::wakeup(void) {
+    // interface specific wakeups - each one is unique!
+    if (spi_dev) {
+        // hold CS low for 2ms
+        digitalWrite(_cs, LOW);
+        delay(2);
+    } else if (ser_dev) {
+        uint8_t w[3] = {0x55, 0x00, 0x00};
+        ser_dev->write(w, 3);
+        delay(2);
+    }
+
+    // PN532 will clock stretch I2C during SAMConfig as a "wakeup"
+
+    // need to config SAM to stay in Normal Mode
+    SAMConfig();
+}
+
+/**************************************************************************/
+/*!
+    @brief  Prints a hexadecimal value in plain characters
+
+    @param  data      Pointer to the byte data
+    @param  numBytes  Data length in bytes
+*/
+/**************************************************************************/
+void Adafruit_PN532::PrintHex(const byte *data, const uint32_t numBytes) {
+    uint32_t szPos;
+    for (szPos = 0; szPos < numBytes; szPos++) {
+        PN532DEBUGPRINT.print(F("0x"));
+        // Append leading 0 for small values
+        if (data[szPos] <= 0xF)
+            PN532DEBUGPRINT.print(F("0"));
+        PN532DEBUGPRINT.print(data[szPos] & 0xff, HEX);
+        if ((numBytes > 1) && (szPos != numBytes - 1)) {
+            PN532DEBUGPRINT.print(F(" "));
+        }
+    }
+    PN532DEBUGPRINT.println();
+}
+
+/**************************************************************************/
+/*!
+    @brief  Prints a hexadecimal value in plain characters, along with
+            the char equivalents in the following format
+
+            00 00 00 00 00 00  ......
+
+    @param  data      Pointer to the byte data
+    @param  numBytes  Data length in bytes
+*/
+/**************************************************************************/
+void Adafruit_PN532::PrintHexChar(const byte *data, const uint32_t numBytes) {
+    uint32_t szPos;
+    for (szPos = 0; szPos < numBytes; szPos++) {
+        // Append leading 0 for small values
+        if (data[szPos] <= 0xF)
+            PN532DEBUGPRINT.print(F("0"));
+        PN532DEBUGPRINT.print(data[szPos], HEX);
+        if ((numBytes > 1) && (szPos != numBytes - 1)) {
+            PN532DEBUGPRINT.print(F(" "));
+        }
+    }
+    PN532DEBUGPRINT.print(F("  "));
+    for (szPos = 0; szPos < numBytes; szPos++) {
+        if (data[szPos] <= 0x1F)
+            PN532DEBUGPRINT.print(F("."));
+        else
+            PN532DEBUGPRINT.print((char)data[szPos]);
+    }
+    PN532DEBUGPRINT.println();
+}
+
+/**************************************************************************/
+/*!
+    @brief  Checks the firmware version of the PN5xx chip
+
+    @returns  The chip's firmware version and ID
+*/
+/**************************************************************************/
+uint32_t Adafruit_PN532::getFirmwareVersion(void) {
+    uint32_t response;
+
+    pn532_packetbuffer[0] = PN532_COMMAND_GETFIRMWAREVERSION;
+
+    if (!sendCommandCheckAck(pn532_packetbuffer, 1)) {
+        return 0;
+    }
+
+    // read data packet
+    readdata(pn532_packetbuffer, 13);
+
+    // check some basic stuff
+    if (0 != memcmp((char *)pn532_packetbuffer,
+                    (char *)pn532response_firmwarevers, 6)) {
+#ifdef PN532DEBUG
+        PN532DEBUGPRINT.println(F("Firmware doesn't match!"));
+#endif
+        return 0;
+    }
+
+    int offset = 7;
+    response = pn532_packetbuffer[offset++];
+    response <<= 8;
+    response |= pn532_packetbuffer[offset++];
+    response <<= 8;
+    response |= pn532_packetbuffer[offset++];
+    response <<= 8;
+    response |= pn532_packetbuffer[offset++];
+
+    return response;
+}
+
+/**************************************************************************/
+/*!
+    @brief  Sends a command and waits a specified period for the ACK
+
+    @param  cmd       Pointer to the command buffer
+    @param  cmdlen    The size of the command in bytes
+    @param  timeout   timeout before giving up
+
+    @returns  1 if everything is OK, 0 if timeout occured before an
+              ACK was recieved
+*/
+/**************************************************************************/
+// default timeout of one second
+bool Adafruit_PN532::sendCommandCheckAck(uint8_t *cmd, uint8_t cmdlen,
+                                         uint16_t timeout) {
+
+    // I2C works without using IRQ pin by polling for RDY byte
+    // seems to work best with some delays between transactions
+    uint8_t SLOWDOWN = 0;
+    if (i2c_dev || spi_dev) // SPI and I2C need 1ms slow for page reads
+        SLOWDOWN = 1;
+
+    // write the command
+    writecommand(cmd, cmdlen);
+
+    // I2C TUNING
+    delay(SLOWDOWN);
+
+    // Wait for chip to say its ready!
+    if (!waitready(timeout)) {
+        return false;
+    }
+
+#ifdef PN532DEBUG
+    if (spi_dev == NULL) {
+        PN532DEBUGPRINT.println(F("IRQ received"));
+    }
+#endif
+
+    // read acknowledgement
+    if (!readack()) {
+#ifdef PN532DEBUG
+        PN532DEBUGPRINT.println(F("No ACK frame received!"));
+#endif
+        return false;
+    }
+
+    // I2C TUNING
+    delay(SLOWDOWN);
+
+    // Wait for chip to say its ready!
+    if (!waitready(timeout)) {
+        return false;
+    }
+
+    return true; // ack'd command
+}
+
+/**************************************************************************/
+/*!
+    @brief   Writes an 8-bit value that sets the state of the PN532's GPIO
+             pins.
+    @param   pinstate  P3 pins state.
+
+    @warning This function is provided exclusively for board testing and
+             is dangerous since it will throw an error if any pin other
+             than the ones marked "Can be used as GPIO" are modified!  All
+             pins that can not be used as GPIO should ALWAYS be left high
+             (value = 1) or the system will become unstable and a HW reset
+             will be required to recover the PN532.
+
+             pinState[0]  = P30     Can be used as GPIO
+             pinState[1]  = P31     Can be used as GPIO
+             pinState[2]  = P32     *** RESERVED (Must be 1!) ***
+             pinState[3]  = P33     Can be used as GPIO
+             pinState[4]  = P34     *** RESERVED (Must be 1!) ***
+             pinState[5]  = P35     Can be used as GPIO
+
+    @return  1 if everything executed properly, 0 for an error
+*/
+/**************************************************************************/
+bool Adafruit_PN532::writeGPIO(uint8_t pinstate) {
+    // uint8_t errorbit;
+
+    // Make sure pinstate does not try to toggle P32 or P34
+    pinstate |= (1 << PN532_GPIO_P32) | (1 << PN532_GPIO_P34);
+
+    // Fill command buffer
+    pn532_packetbuffer[0] = PN532_COMMAND_WRITEGPIO;
+    pn532_packetbuffer[1] = PN532_GPIO_VALIDATIONBIT | pinstate; // P3 Pins
+    pn532_packetbuffer[2] = 0x00; // P7 GPIO Pins (not used ... taken by SPI)
+
+#ifdef PN532DEBUG
+    PN532DEBUGPRINT.print(F("Writing P3 GPIO: "));
+    PN532DEBUGPRINT.println(pn532_packetbuffer[1], HEX);
+#endif
+
+    // Send the WRITEGPIO command (0x0E)
+    if (!sendCommandCheckAck(pn532_packetbuffer, 3))
+        return 0x0;
+
+    // Read response packet (00 FF PLEN PLENCHECKSUM D5 CMD+1(0x0F) DATACHECKSUM
+    // 00)
+    readdata(pn532_packetbuffer, 8);
+
+#ifdef PN532DEBUG
+    PN532DEBUGPRINT.print(F("Received: "));
+    PrintHex(pn532_packetbuffer, 8);
+    PN532DEBUGPRINT.println();
+#endif
+
+    int offset = 6;
+    return (pn532_packetbuffer[offset] == 0x0F);
+}
+
+/**************************************************************************/
+/*!
+    Reads the state of the PN532's GPIO pins
+
+    @returns An 8-bit value containing the pin state where:
+
+             pinState[0]  = P30
+             pinState[1]  = P31
+             pinState[2]  = P32
+             pinState[3]  = P33
+             pinState[4]  = P34
+             pinState[5]  = P35
+*/
+/**************************************************************************/
+uint8_t Adafruit_PN532::readGPIO(void) {
+    pn532_packetbuffer[0] = PN532_COMMAND_READGPIO;
+
+    // Send the READGPIO command (0x0C)
+    if (!sendCommandCheckAck(pn532_packetbuffer, 1))
+        return 0x0;
+
+    // Read response packet (00 FF PLEN PLENCHECKSUM D5 CMD+1(0x0D) P3 P7 IO1
+    // DATACHECKSUM 00)
+    readdata(pn532_packetbuffer, 11);
+
+    /* READGPIO response should be in the following format:
+
+      byte            Description
+      -------------   ------------------------------------------
+      b0..5           Frame header and preamble (with I2C there is an extra
+      0x00) b6              P3 GPIO Pins b7              P7 GPIO Pins (not used
+      ... taken by SPI) b8              Interface Mode Pins (not used ... bus
+      select pins) b9..10          checksum */
+
+    int p3offset = 7;
+
+#ifdef PN532DEBUG
+    PN532DEBUGPRINT.print(F("Received: "));
+    PrintHex(pn532_packetbuffer, 11);
+    PN532DEBUGPRINT.println();
+    PN532DEBUGPRINT.print(F("P3 GPIO: 0x"));
+    PN532DEBUGPRINT.println(pn532_packetbuffer[p3offset], HEX);
+    PN532DEBUGPRINT.print(F("P7 GPIO: 0x"));
+    PN532DEBUGPRINT.println(pn532_packetbuffer[p3offset + 1], HEX);
+    PN532DEBUGPRINT.print(F("IO GPIO: 0x"));
+    PN532DEBUGPRINT.println(pn532_packetbuffer[p3offset + 2], HEX);
+    // Note: You can use the IO GPIO value to detect the serial bus being used
+    switch (pn532_packetbuffer[p3offset + 2]) {
+    case 0x00: // Using UART
+        PN532DEBUGPRINT.println(F("Using UART (IO = 0x00)"));
+        break;
+    case 0x01: // Using I2C
+        PN532DEBUGPRINT.println(F("Using I2C (IO = 0x01)"));
+        break;
+    case 0x02: // Using SPI
+        PN532DEBUGPRINT.println(F("Using SPI (IO = 0x02)"));
+        break;
+    }
+#endif
+
+    return pn532_packetbuffer[p3offset];
+}
+
+/**************************************************************************/
+/*!
+    @brief   Configures the SAM (Secure Access Module)
+    @return  true on success, false otherwise.
+*/
+/**************************************************************************/
+bool Adafruit_PN532::SAMConfig(void) {
+    pn532_packetbuffer[0] = PN532_COMMAND_SAMCONFIGURATION;
+    pn532_packetbuffer[1] = 0x01; // normal mode;
+    pn532_packetbuffer[2] = 0x14; // timeout 50ms * 20 = 1 second
+    pn532_packetbuffer[3] = 0x01; // use IRQ pin!
+
+    if (!sendCommandCheckAck(pn532_packetbuffer, 4))
+        return false;
+
+    // read data packet
+    readdata(pn532_packetbuffer, 9);
+
+    int offset = 6;
+    return (pn532_packetbuffer[offset] == 0x15);
+}
+
+/**************************************************************************/
+/*!
+    Sets the MxRtyPassiveActivation byte of the RFConfiguration register
+
+    @param  maxRetries    0xFF to wait forever, 0x00..0xFE to timeout
+                          after mxRetries
+
+    @returns 1 if everything executed properly, 0 for an error
+*/
+/**************************************************************************/
+bool Adafruit_PN532::setPassiveActivationRetries(uint8_t maxRetries) {
+    pn532_packetbuffer[0] = PN532_COMMAND_RFCONFIGURATION;
+    pn532_packetbuffer[1] = 5;    // Config item 5 (MaxRetries)
+    pn532_packetbuffer[2] = 0xFF; // MxRtyATR (default = 0xFF)
+    pn532_packetbuffer[3] = 0x01; // MxRtyPSL (default = 0x01)
+    pn532_packetbuffer[4] = maxRetries;
+
+#ifdef MIFAREDEBUG
+    PN532DEBUGPRINT.print(F("Setting MxRtyPassiveActivation to "));
+    PN532DEBUGPRINT.print(maxRetries, DEC);
+    PN532DEBUGPRINT.println(F(" "));
+#endif
+
+    if (!sendCommandCheckAck(pn532_packetbuffer, 5))
+        return 0x0; // no ACK
+
+    return 1;
+}
+
+/***** ISO14443A Commands ******/
+
+/**************************************************************************/
+/*!
+    @brief   Waits for an ISO14443A target to enter the field and reads
+             its ID.
+
+    @param   cardbaudrate  Baud rate of the card
+    @param   uid           Pointer to the array that will be populated
+                           with the card's UID (up to 7 bytes)
+    @param   uidLength     Pointer to the variable that will hold the
+                           length of the card's UID.
+    @param   timeout       Timeout in milliseconds.
+
+    @return  1 if everything executed properly, 0 for an error
+*/
+/**************************************************************************/
+bool Adafruit_PN532::readPassiveTargetID(uint8_t cardbaudrate, uint8_t *uid,
+                                         uint8_t *uidLength, uint16_t timeout) {
+    pn532_packetbuffer[0] = PN532_COMMAND_INLISTPASSIVETARGET;
+    pn532_packetbuffer[1] =
+        1; // max 1 cards at once (we can set this to 2 later)
+    pn532_packetbuffer[2] = cardbaudrate;
+
+    if (!sendCommandCheckAck(pn532_packetbuffer, 3, timeout)) {
+#ifdef PN532DEBUG
+        PN532DEBUGPRINT.println(F("No card(s) read"));
+#endif
+        return 0x0; // no cards read
+    }
+
+    return readDetectedPassiveTargetID(uid, uidLength);
+}
+
+/**************************************************************************/
+/*!
+    @brief   Put the reader in detection mode, non blocking so interrupts
+             must be enabled.
+    @param   cardbaudrate  Baud rate of the card
+    @return  1 if everything executed properly, 0 for an error
+*/
+/**************************************************************************/
+bool Adafruit_PN532::startPassiveTargetIDDetection(uint8_t cardbaudrate) {
+    pn532_packetbuffer[0] = PN532_COMMAND_INLISTPASSIVETARGET;
+    pn532_packetbuffer[1] =
+        1; // max 1 cards at once (we can set this to 2 later)
+    pn532_packetbuffer[2] = cardbaudrate;
+
+    return sendCommandCheckAck(pn532_packetbuffer, 3);
+}
+
+/**************************************************************************/
+/*!
+    Reads the ID of the passive target the reader has deteceted.
+
+    @param  uid           Pointer to the array that will be populated
+                          with the card's UID (up to 7 bytes)
+    @param  uidLength     Pointer to the variable that will hold the
+                          length of the card's UID.
+
+    @returns 1 if everything executed properly, 0 for an error
+*/
+/**************************************************************************/
+bool Adafruit_PN532::readDetectedPassiveTargetID(uint8_t *uid,
+                                                 uint8_t *uidLength) {
+    // read data packet
+    readdata(pn532_packetbuffer, 20);
+    // check some basic stuff
+
+    /* ISO14443A card response should be in the following format:
+
+      byte            Description
+      -------------   ------------------------------------------
+      b0..6           Frame header and preamble
+      b7              Tags Found
+      b8              Tag Number (only one used in this example)
+      b9..10          SENS_RES
+      b11             SEL_RES
+      b12             NFCID Length
+      b13..NFCIDLen   NFCID                                      */
+
+#ifdef MIFAREDEBUG
+    PN532DEBUGPRINT.print(F("Found "));
+    PN532DEBUGPRINT.print(pn532_packetbuffer[7], DEC);
+    PN532DEBUGPRINT.println(F(" tags"));
+#endif
+    if (pn532_packetbuffer[7] != 1)
+        return 0;
+
+    uint16_t sens_res = pn532_packetbuffer[9];
+    sens_res <<= 8;
+    sens_res |= pn532_packetbuffer[10];
+#ifdef MIFAREDEBUG
+    PN532DEBUGPRINT.print(F("ATQA: 0x"));
+    PN532DEBUGPRINT.println(sens_res, HEX);
+    PN532DEBUGPRINT.print(F("SAK: 0x"));
+    PN532DEBUGPRINT.println(pn532_packetbuffer[11], HEX);
+#endif
+
+    /* Card appears to be Mifare Classic */
+    *uidLength = pn532_packetbuffer[12];
+#ifdef MIFAREDEBUG
+    PN532DEBUGPRINT.print(F("UID:"));
+#endif
+    for (uint8_t i = 0; i < pn532_packetbuffer[12]; i++) {
+        uid[i] = pn532_packetbuffer[13 + i];
+#ifdef MIFAREDEBUG
+        PN532DEBUGPRINT.print(F(" 0x"));
+        PN532DEBUGPRINT.print(uid[i], HEX);
+#endif
+    }
+#ifdef MIFAREDEBUG
+    PN532DEBUGPRINT.println();
+#endif
+
+    return 1;
+}
+
+/**************************************************************************/
+/*!
+    @brief   Exchanges an APDU with the currently inlisted peer
+
+    @param   send            Pointer to data to send
+    @param   sendLength      Length of the data to send
+    @param   response        Pointer to response data
+    @param   responseLength  Pointer to the response data length
+    @return  true on success, false otherwise.
+*/
+/**************************************************************************/
+bool Adafruit_PN532::inDataExchange(uint8_t *send, uint8_t sendLength,
+                                    uint8_t *response,
+                                    uint8_t *responseLength) {
+    if (sendLength > PN532_PACKBUFFSIZ - 2) {
+#ifdef PN532DEBUG
+        PN532DEBUGPRINT.println(F("APDU length too long for packet buffer"));
+#endif
+        return false;
+    }
+    uint8_t i;
+
+    pn532_packetbuffer[0] = 0x40; // PN532_COMMAND_INDATAEXCHANGE;
+    pn532_packetbuffer[1] = _inListedTag;
+    for (i = 0; i < sendLength; ++i) {
+        pn532_packetbuffer[i + 2] = send[i];
+    }
+
+    if (!sendCommandCheckAck(pn532_packetbuffer, sendLength + 2, 1000)) {
+#ifdef PN532DEBUG
+        PN532DEBUGPRINT.println(F("Could not send APDU"));
+#endif
+        return false;
+    }
+
+    if (!waitready(1000)) {
+#ifdef PN532DEBUG
+        PN532DEBUGPRINT.println(F("Response never received for APDU..."));
+#endif
+        return false;
+    }
+
+    readdata(pn532_packetbuffer, sizeof(pn532_packetbuffer));
+
+    if (pn532_packetbuffer[0] == 0 && pn532_packetbuffer[1] == 0 &&
+        pn532_packetbuffer[2] == 0xff) {
+        uint8_t length = pn532_packetbuffer[3];
+        if (pn532_packetbuffer[4] != (uint8_t)(~length + 1)) {
+#ifdef PN532DEBUG
+            PN532DEBUGPRINT.println(F("Length check invalid"));
+            PN532DEBUGPRINT.println(length, HEX);
+            PN532DEBUGPRINT.println((~length) + 1, HEX);
+#endif
+            return false;
+        }
+        if (pn532_packetbuffer[5] == PN532_PN532TOHOST &&
+            pn532_packetbuffer[6] == PN532_RESPONSE_INDATAEXCHANGE) {
+            if ((pn532_packetbuffer[7] & 0x3f) != 0) {
+#ifdef PN532DEBUG
+                PN532DEBUGPRINT.println(F("Status code indicates an error"));
+#endif
+                return false;
+            }
+
+            length -= 3;
+
+            if (length > *responseLength) {
+                length = *responseLength; // silent truncation...
+            }
+
+            for (i = 0; i < length; ++i) {
+                response[i] = pn532_packetbuffer[8 + i];
+            }
+            *responseLength = length;
+
+            return true;
+        } else {
+            PN532DEBUGPRINT.print(F("Don't know how to handle this command: "));
+            PN532DEBUGPRINT.println(pn532_packetbuffer[6], HEX);
+            return false;
+        }
+    } else {
+        PN532DEBUGPRINT.println(F("Preamble missing"));
+        return false;
+    }
+}
+
+/**************************************************************************/
+/*!
+    @brief   'InLists' a passive target. PN532 acting as reader/initiator,
+             peer acting as card/responder.
+    @return  true on success, false otherwise.
+*/
+/**************************************************************************/
+bool Adafruit_PN532::inListPassiveTarget() {
+    pn532_packetbuffer[0] = PN532_COMMAND_INLISTPASSIVETARGET;
+    pn532_packetbuffer[1] = 1;
+    pn532_packetbuffer[2] = 0;
+
+#ifdef PN532DEBUG
+    PN532DEBUGPRINT.print(F("About to inList passive target"));
+#endif
+
+    if (!sendCommandCheckAck(pn532_packetbuffer, 3, 1000)) {
+#ifdef PN532DEBUG
+        PN532DEBUGPRINT.println(F("Could not send inlist message"));
+#endif
+        return false;
+    }
+
+    if (!waitready(30000)) {
+        return false;
+    }
+
+    readdata(pn532_packetbuffer, sizeof(pn532_packetbuffer));
+
+    if (pn532_packetbuffer[0] == 0 && pn532_packetbuffer[1] == 0 &&
+        pn532_packetbuffer[2] == 0xff) {
+        uint8_t length = pn532_packetbuffer[3];
+        if (pn532_packetbuffer[4] != (uint8_t)(~length + 1)) {
+#ifdef PN532DEBUG
+            PN532DEBUGPRINT.println(F("Length check invalid"));
+            PN532DEBUGPRINT.println(length, HEX);
+            PN532DEBUGPRINT.println((~length) + 1, HEX);
+#endif
+            return false;
+        }
+        if (pn532_packetbuffer[5] == PN532_PN532TOHOST &&
+            pn532_packetbuffer[6] == PN532_RESPONSE_INLISTPASSIVETARGET) {
+            if (pn532_packetbuffer[7] != 1) {
+#ifdef PN532DEBUG
+                PN532DEBUGPRINT.println(
+                    F("Unhandled number of targets inlisted"));
+#endif
+                PN532DEBUGPRINT.println(F("Number of tags inlisted:"));
+                PN532DEBUGPRINT.println(pn532_packetbuffer[7]);
+                return false;
+            }
+
+            _inListedTag = pn532_packetbuffer[8];
+            PN532DEBUGPRINT.print(F("Tag number: "));
+            PN532DEBUGPRINT.println(_inListedTag);
+
+            return true;
+        } else {
+#ifdef PN532DEBUG
+            PN532DEBUGPRINT.print(
+                F("Unexpected response to inlist passive host"));
+#endif
+            return false;
+        }
+    } else {
+#ifdef PN532DEBUG
+        PN532DEBUGPRINT.println(F("Preamble missing"));
+#endif
+        return false;
+    }
+
+    return true;
+}
+
+/***** Mifare Classic Functions ******/
+
+/**************************************************************************/
+/*!
+    @brief   Indicates whether the specified block number is the first block
+             in the sector (block 0 relative to the current sector)
+    @param   uiBlock  Block number to test.
+    @return  true if first block, false otherwise.
+*/
+/**************************************************************************/
+bool Adafruit_PN532::mifareclassic_IsFirstBlock(uint32_t uiBlock) {
+    // Test if we are in the small or big sectors
+    if (uiBlock < 128)
+        return ((uiBlock) % 4 == 0);
+    else
+        return ((uiBlock) % 16 == 0);
+}
+
+/**************************************************************************/
+/*!
+    @brief   Indicates whether the specified block number is the sector
+             trailer.
+    @param   uiBlock  Block number to test.
+    @return  true if sector trailer, false otherwise.
+*/
+/**************************************************************************/
+bool Adafruit_PN532::mifareclassic_IsTrailerBlock(uint32_t uiBlock) {
+    // Test if we are in the small or big sectors
+    if (uiBlock < 128)
+        return ((uiBlock + 1) % 4 == 0);
+    else
+        return ((uiBlock + 1) % 16 == 0);
+}
+
+/**************************************************************************/
+/*!
+    Tries to authenticate a block of memory on a MIFARE card using the
+    INDATAEXCHANGE command.  See section 7.3.8 of the PN532 User Manual
+    for more information on sending MIFARE and other commands.
+
+    @param  uid           Pointer to a byte array containing the card UID
+    @param  uidLen        The length (in bytes) of the card's UID (Should
+                          be 4 for MIFARE Classic)
+    @param  blockNumber   The block number to authenticate.  (0..63 for
+                          1KB cards, and 0..255 for 4KB cards).
+    @param  keyNumber     Which key type to use during authentication
+                          (0 = MIFARE_CMD_AUTH_A, 1 = MIFARE_CMD_AUTH_B)
+    @param  keyData       Pointer to a byte array containing the 6 byte
+                          key value
+
+    @returns 1 if everything executed properly, 0 for an error
+*/
+/**************************************************************************/
+uint8_t Adafruit_PN532::mifareclassic_AuthenticateBlock(uint8_t *uid,
+                                                        uint8_t uidLen,
+                                                        uint32_t blockNumber,
+                                                        uint8_t keyNumber,
+                                                        uint8_t *keyData) {
+    // uint8_t len;
+    uint8_t i;
+
+    // Hang on to the key and uid data
+    memcpy(_key, keyData, 6);
+    memcpy(_uid, uid, uidLen);
+    _uidLen = uidLen;
+
+#ifdef MIFAREDEBUG
+    PN532DEBUGPRINT.print(F("Trying to authenticate card "));
+    Adafruit_PN532::PrintHex(_uid, _uidLen);
+    PN532DEBUGPRINT.print(F("Using authentication KEY "));
+    PN532DEBUGPRINT.print(keyNumber ? 'B' : 'A');
+    PN532DEBUGPRINT.print(F(": "));
+    Adafruit_PN532::PrintHex(_key, 6);
+#endif
+
+    // Prepare the authentication command //
+    pn532_packetbuffer[0] =
+        PN532_COMMAND_INDATAEXCHANGE; /* Data Exchange Header */
+    pn532_packetbuffer[1] = 1;        /* Max card numbers */
+    pn532_packetbuffer[2] = (keyNumber) ? MIFARE_CMD_AUTH_B : MIFARE_CMD_AUTH_A;
+    pn532_packetbuffer[3] =
+        blockNumber; /* Block Number (1K = 0..63, 4K = 0..255 */
+    memcpy(pn532_packetbuffer + 4, _key, 6);
+    for (i = 0; i < _uidLen; i++) {
+        pn532_packetbuffer[10 + i] = _uid[i]; /* 4 byte card ID */
+    }
+
+    if (!sendCommandCheckAck(pn532_packetbuffer, 10 + _uidLen))
+        return 0;
+
+    // Read the response packet
+    readdata(pn532_packetbuffer, 12);
+
+    // check if the response is valid and we are authenticated???
+    // for an auth success it should be bytes 5-7: 0xD5 0x41 0x00
+    // Mifare auth error is technically byte 7: 0x14 but anything other and 0x00
+    // is not good
+    if (pn532_packetbuffer[7] != 0x00) {
+#ifdef PN532DEBUG
+        PN532DEBUGPRINT.print(F("Authentification failed: "));
+        Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 12);
+#endif
+        return 0;
+    }
+
+    return 1;
+}
+
+/**************************************************************************/
+/*!
+    Tries to read an entire 16-byte data block at the specified block
+    address.
+
+    @param  blockNumber   The block number to authenticate.  (0..63 for
+                          1KB cards, and 0..255 for 4KB cards).
+    @param  data          Pointer to the byte array that will hold the
+                          retrieved data (if any)
+
+    @returns 1 if everything executed properly, 0 for an error
+*/
+/**************************************************************************/
+uint8_t Adafruit_PN532::mifareclassic_ReadDataBlock(uint8_t blockNumber,
+                                                    uint8_t *data) {
+#ifdef MIFAREDEBUG
+    PN532DEBUGPRINT.print(F("Trying to read 16 bytes from block "));
+    PN532DEBUGPRINT.println(blockNumber);
+#endif
+
+    /* Prepare the command */
+    pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE;
+    pn532_packetbuffer[1] = 1;               /* Card number */
+    pn532_packetbuffer[2] = MIFARE_CMD_READ; /* Mifare Read command = 0x30 */
+    pn532_packetbuffer[3] =
+        blockNumber; /* Block Number (0..63 for 1K, 0..255 for 4K) */
+
+    /* Send the command */
+    if (!sendCommandCheckAck(pn532_packetbuffer, 4)) {
+#ifdef MIFAREDEBUG
+        PN532DEBUGPRINT.println(F("Failed to receive ACK for read command"));
+#endif
+        return 0;
+    }
+
+    /* Read the response packet */
+    readdata(pn532_packetbuffer, 26);
+
+    /* If byte 8 isn't 0x00 we probably have an error */
+    if (pn532_packetbuffer[7] != 0x00) {
+#ifdef MIFAREDEBUG
+        PN532DEBUGPRINT.println(F("Unexpected response"));
+        Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26);
+#endif
+        return 0;
+    }
+
+    /* Copy the 16 data bytes to the output buffer        */
+    /* Block content starts at byte 9 of a valid response */
+    memcpy(data, pn532_packetbuffer + 8, 16);
+
+/* Display data for debug if requested */
+#ifdef MIFAREDEBUG
+    PN532DEBUGPRINT.print(F("Block "));
+    PN532DEBUGPRINT.println(blockNumber);
+    Adafruit_PN532::PrintHexChar(data, 16);
+#endif
+
+    return 1;
+}
+
+/**************************************************************************/
+/*!
+    Tries to write an entire 16-byte data block at the specified block
+    address.
+
+    @param  blockNumber   The block number to authenticate.  (0..63 for
+                          1KB cards, and 0..255 for 4KB cards).
+    @param  data          The byte array that contains the data to write.
+
+    @returns 1 if everything executed properly, 0 for an error
+*/
+/**************************************************************************/
+uint8_t Adafruit_PN532::mifareclassic_WriteDataBlock(uint8_t blockNumber,
+                                                     uint8_t *data) {
+#ifdef MIFAREDEBUG
+    PN532DEBUGPRINT.print(F("Trying to write 16 bytes to block "));
+    PN532DEBUGPRINT.println(blockNumber);
+#endif
+
+    /* Prepare the first command */
+    pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE;
+    pn532_packetbuffer[1] = 1;                /* Card number */
+    pn532_packetbuffer[2] = MIFARE_CMD_WRITE; /* Mifare Write command = 0xA0 */
+    pn532_packetbuffer[3] =
+        blockNumber; /* Block Number (0..63 for 1K, 0..255 for 4K) */
+    memcpy(pn532_packetbuffer + 4, data, 16); /* Data Payload */
+
+    /* Send the command */
+    if (!sendCommandCheckAck(pn532_packetbuffer, 20)) {
+#ifdef MIFAREDEBUG
+        PN532DEBUGPRINT.println(F("Failed to receive ACK for write command"));
+#endif
+        return 0;
+    }
+    delay(10);
+
+    /* Read the response packet */
+    readdata(pn532_packetbuffer, 26);
+
+    return 1;
+}
+
+/**************************************************************************/
+/*!
+    Formats a Mifare Classic card to store NDEF Records
+
+    @returns 1 if everything executed properly, 0 for an error
+*/
+/**************************************************************************/
+uint8_t Adafruit_PN532::mifareclassic_FormatNDEF(void) {
+    uint8_t sectorbuffer1[16] = {0x14, 0x01, 0x03, 0xE1, 0x03, 0xE1,
+                                 0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1,
+                                 0x03, 0xE1, 0x03, 0xE1};
+    uint8_t sectorbuffer2[16] = {0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1,
+                                 0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1,
+                                 0x03, 0xE1, 0x03, 0xE1};
+    uint8_t sectorbuffer3[16] = {0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5,
+                                 0x78, 0x77, 0x88, 0xC1, 0xFF, 0xFF,
+                                 0xFF, 0xFF, 0xFF, 0xFF};
+
+    // Note 0xA0 0xA1 0xA2 0xA3 0xA4 0xA5 must be used for key A
+    // for the MAD sector in NDEF records (sector 0)
+
+    // Write block 1 and 2 to the card
+    if (!(mifareclassic_WriteDataBlock(1, sectorbuffer1)))
+        return 0;
+    if (!(mifareclassic_WriteDataBlock(2, sectorbuffer2)))
+        return 0;
+    // Write key A and access rights card
+    if (!(mifareclassic_WriteDataBlock(3, sectorbuffer3)))
+        return 0;
+
+    // Seems that everything was OK (?!)
+    return 1;
+}
+
+/**************************************************************************/
+/*!
+    Writes an NDEF URI Record to the specified sector (1..15)
+
+    Note that this function assumes that the Mifare Classic card is
+    already formatted to work as an "NFC Forum Tag" and uses a MAD1
+    file system.  You can use the NXP TagWriter app on Android to
+    properly format cards for this.
+
+    @param  sectorNumber  The sector that the URI record should be written
+                          to (can be 1..15 for a 1K card)
+    @param  uriIdentifier The uri identifier code (0 = none, 0x01 =
+                          "http://www.", etc.)
+    @param  url           The uri text to write (max 38 characters).
+
+    @returns 1 if everything executed properly, 0 for an error
+*/
+/**************************************************************************/
+uint8_t Adafruit_PN532::mifareclassic_WriteNDEFURI(uint8_t sectorNumber,
+                                                   uint8_t uriIdentifier,
+                                                   const char *url) {
+    // Figure out how long the string is
+    uint8_t len = strlen(url);
+
+    // Make sure we're within a 1K limit for the sector number
+    if ((sectorNumber < 1) || (sectorNumber > 15))
+        return 0;
+
+    // Make sure the URI payload is between 1 and 38 chars
+    if ((len < 1) || (len > 38))
+        return 0;
+
+    // Note 0xD3 0xF7 0xD3 0xF7 0xD3 0xF7 must be used for key A
+    // in NDEF records
+
+    // Setup the sector buffer (w/pre-formatted TLV wrapper and NDEF message)
+    uint8_t sectorbuffer1[16] = {0x00,
+                                 0x00,
+                                 0x03,
+                                 (uint8_t)(len + 5),
+                                 0xD1,
+                                 0x01,
+                                 (uint8_t)(len + 1),
+                                 0x55,
+                                 uriIdentifier,
+                                 0x00,
+                                 0x00,
+                                 0x00,
+                                 0x00,
+                                 0x00,
+                                 0x00,
+                                 0x00};
+    uint8_t sectorbuffer2[16] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00};
+    uint8_t sectorbuffer3[16] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00};
+    uint8_t sectorbuffer4[16] = {0xD3, 0xF7, 0xD3, 0xF7, 0xD3, 0xF7,
+                                 0x7F, 0x07, 0x88, 0x40, 0xFF, 0xFF,
+                                 0xFF, 0xFF, 0xFF, 0xFF};
+    if (len <= 6) {
+        // Unlikely we'll get a url this short, but why not ...
+        memcpy(sectorbuffer1 + 9, url, len);
+        sectorbuffer1[len + 9] = 0xFE;
+    } else if (len == 7) {
+        // 0xFE needs to be wrapped around to next block
+        memcpy(sectorbuffer1 + 9, url, len);
+        sectorbuffer2[0] = 0xFE;
+    } else if ((len > 7) && (len <= 22)) {
+        // Url fits in two blocks
+        memcpy(sectorbuffer1 + 9, url, 7);
+        memcpy(sectorbuffer2, url + 7, len - 7);
+        sectorbuffer2[len - 7] = 0xFE;
+    } else if (len == 23) {
+        // 0xFE needs to be wrapped around to final block
+        memcpy(sectorbuffer1 + 9, url, 7);
+        memcpy(sectorbuffer2, url + 7, len - 7);
+        sectorbuffer3[0] = 0xFE;
+    } else {
+        // Url fits in three blocks
+        memcpy(sectorbuffer1 + 9, url, 7);
+        memcpy(sectorbuffer2, url + 7, 16);
+        memcpy(sectorbuffer3, url + 23, len - 24);
+        sectorbuffer3[len - 22] = 0xFE;
+    }
+
+    // Now write all three blocks back to the card
+    if (!(mifareclassic_WriteDataBlock(sectorNumber * 4, sectorbuffer1)))
+        return 0;
+    if (!(mifareclassic_WriteDataBlock((sectorNumber * 4) + 1, sectorbuffer2)))
+        return 0;
+    if (!(mifareclassic_WriteDataBlock((sectorNumber * 4) + 2, sectorbuffer3)))
+        return 0;
+    if (!(mifareclassic_WriteDataBlock((sectorNumber * 4) + 3, sectorbuffer4)))
+        return 0;
+
+    // Seems that everything was OK (?!)
+    return 1;
+}
+
+/***** Mifare Ultralight Functions ******/
+
+/**************************************************************************/
+/*!
+    @brief   Tries to read an entire 4-byte page at the specified address.
+
+    @param   page        The page number (0..63 in most cases)
+    @param   buffer      Pointer to the byte array that will hold the
+                         retrieved data (if any)
+    @return  1 on success, 0 on error.
+*/
+/**************************************************************************/
+uint8_t Adafruit_PN532::mifareultralight_ReadPage(uint8_t page,
+                                                  uint8_t *buffer) {
+    if (page >= 64) {
+#ifdef MIFAREDEBUG
+        PN532DEBUGPRINT.println(F("Page value out of range"));
+#endif
+        return 0;
+    }
+
+#ifdef MIFAREDEBUG
+    PN532DEBUGPRINT.print(F("Reading page "));
+    PN532DEBUGPRINT.println(page);
+#endif
+
+    /* Prepare the command */
+    pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE;
+    pn532_packetbuffer[1] = 1;               /* Card number */
+    pn532_packetbuffer[2] = MIFARE_CMD_READ; /* Mifare Read command = 0x30 */
+    pn532_packetbuffer[3] = page; /* Page Number (0..63 in most cases) */
+
+    /* Send the command */
+    if (!sendCommandCheckAck(pn532_packetbuffer, 4)) {
+#ifdef MIFAREDEBUG
+        PN532DEBUGPRINT.println(F("Failed to receive ACK for write command"));
+#endif
+        return 0;
+    }
+
+    /* Read the response packet */
+    readdata(pn532_packetbuffer, 26);
+#ifdef MIFAREDEBUG
+    PN532DEBUGPRINT.println(F("Received: "));
+    Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26);
+#endif
+
+    /* If byte 8 isn't 0x00 we probably have an error */
+    if (pn532_packetbuffer[7] == 0x00) {
+        /* Copy the 4 data bytes to the output buffer         */
+        /* Block content starts at byte 9 of a valid response */
+        /* Note that the command actually reads 16 byte or 4  */
+        /* pages at a time ... we simply discard the last 12  */
+        /* bytes                                              */
+        memcpy(buffer, pn532_packetbuffer + 8, 4);
+    } else {
+#ifdef MIFAREDEBUG
+        PN532DEBUGPRINT.println(F("Unexpected response reading block: "));
+        Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26);
+#endif
+        return 0;
+    }
+
+/* Display data for debug if requested */
+#ifdef MIFAREDEBUG
+    PN532DEBUGPRINT.print(F("Page "));
+    PN532DEBUGPRINT.print(page);
+    PN532DEBUGPRINT.println(F(":"));
+    Adafruit_PN532::PrintHexChar(buffer, 4);
+#endif
+
+    // Return OK signal
+    return 1;
+}
+
+/**************************************************************************/
+/*!
+    Tries to write an entire 4-byte page at the specified block
+    address.
+
+    @param  page          The page number to write.  (0..63 for most cases)
+    @param  data          The byte array that contains the data to write.
+                          Should be exactly 4 bytes long.
+
+    @returns 1 if everything executed properly, 0 for an error
+*/
+/**************************************************************************/
+uint8_t Adafruit_PN532::mifareultralight_WritePage(uint8_t page,
+                                                   uint8_t *data) {
+
+    if (page >= 64) {
+#ifdef MIFAREDEBUG
+        PN532DEBUGPRINT.println(F("Page value out of range"));
+#endif
+        // Return Failed Signal
+        return 0;
+    }
+
+#ifdef MIFAREDEBUG
+    PN532DEBUGPRINT.print(F("Trying to write 4 byte page"));
+    PN532DEBUGPRINT.println(page);
+#endif
+
+    /* Prepare the first command */
+    pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE;
+    pn532_packetbuffer[1] = 1; /* Card number */
+    pn532_packetbuffer[2] =
+        MIFARE_ULTRALIGHT_CMD_WRITE; /* Mifare Ultralight Write command = 0xA2
+                                      */
+    pn532_packetbuffer[3] = page;    /* Page Number (0..63 for most cases) */
+    memcpy(pn532_packetbuffer + 4, data, 4); /* Data Payload */
+
+    /* Send the command */
+    if (!sendCommandCheckAck(pn532_packetbuffer, 8)) {
+#ifdef MIFAREDEBUG
+        PN532DEBUGPRINT.println(F("Failed to receive ACK for write command"));
+#endif
+
+        // Return Failed Signal
+        return 0;
+    }
+    delay(10);
+
+    /* Read the response packet */
+    readdata(pn532_packetbuffer, 26);
+
+    // Return OK Signal
+    return 1;
+}
+
+/***** NTAG2xx Functions ******/
+
+/**************************************************************************/
+/*!
+    @brief   Tries to read an entire 4-byte page at the specified address.
+
+    @param   page        The page number (0..63 in most cases)
+    @param   buffer      Pointer to the byte array that will hold the
+                         retrieved data (if any)
+    @return  1 on success, 0 on error.
+*/
+/**************************************************************************/
+uint8_t Adafruit_PN532::ntag2xx_ReadPage(uint8_t page, uint8_t *buffer) {
+    // TAG Type       PAGES   USER START    USER STOP
+    // --------       -----   ----------    ---------
+    // NTAG 203       42      4             39
+    // NTAG 213       45      4             39
+    // NTAG 215       135     4             129
+    // NTAG 216       231     4             225
+
+    if (page >= 231) {
+#ifdef MIFAREDEBUG
+        PN532DEBUGPRINT.println(F("Page value out of range"));
+#endif
+        return 0;
+    }
+
+#ifdef MIFAREDEBUG
+    PN532DEBUGPRINT.print(F("Reading page "));
+    PN532DEBUGPRINT.println(page);
+#endif
+
+    /* Prepare the command */
+    pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE;
+    pn532_packetbuffer[1] = 1;               /* Card number */
+    pn532_packetbuffer[2] = MIFARE_CMD_READ; /* Mifare Read command = 0x30 */
+    pn532_packetbuffer[3] = page; /* Page Number (0..63 in most cases) */
+
+    /* Send the command */
+    if (!sendCommandCheckAck(pn532_packetbuffer, 4)) {
+#ifdef MIFAREDEBUG
+        PN532DEBUGPRINT.println(F("Failed to receive ACK for write command"));
+#endif
+        return 0;
+    }
+
+    /* Read the response packet */
+    readdata(pn532_packetbuffer, 26);
+#ifdef MIFAREDEBUG
+    PN532DEBUGPRINT.println(F("Received: "));
+    Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26);
+#endif
+
+    /* If byte 8 isn't 0x00 we probably have an error */
+    if (pn532_packetbuffer[7] == 0x00) {
+        /* Copy the 4 data bytes to the output buffer         */
+        /* Block content starts at byte 9 of a valid response */
+        /* Note that the command actually reads 16 byte or 4  */
+        /* pages at a time ... we simply discard the last 12  */
+        /* bytes                                              */
+        memcpy(buffer, pn532_packetbuffer + 8, 4);
+    } else {
+#ifdef MIFAREDEBUG
+        PN532DEBUGPRINT.println(F("Unexpected response reading block: "));
+        Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26);
+#endif
+        return 0;
+    }
+
+/* Display data for debug if requested */
+#ifdef MIFAREDEBUG
+    PN532DEBUGPRINT.print(F("Page "));
+    PN532DEBUGPRINT.print(page);
+    PN532DEBUGPRINT.println(F(":"));
+    Adafruit_PN532::PrintHexChar(buffer, 4);
+#endif
+
+    // Return OK signal
+    return 1;
+}
+
+/**************************************************************************/
+/*!
+    Tries to write an entire 4-byte page at the specified block
+    address.
+
+    @param  page          The page number to write.  (0..63 for most cases)
+    @param  data          The byte array that contains the data to write.
+                          Should be exactly 4 bytes long.
+
+    @returns 1 if everything executed properly, 0 for an error
+*/
+/**************************************************************************/
+uint8_t Adafruit_PN532::ntag2xx_WritePage(uint8_t page, uint8_t *data) {
+    // TAG Type       PAGES   USER START    USER STOP
+    // --------       -----   ----------    ---------
+    // NTAG 203       42      4             39
+    // NTAG 213       45      4             39
+    // NTAG 215       135     4             129
+    // NTAG 216       231     4             225
+
+    if ((page < 4) || (page > 225)) {
+#ifdef MIFAREDEBUG
+        PN532DEBUGPRINT.println(F("Page value out of range"));
+#endif
+        // Return Failed Signal
+        return 0;
+    }
+
+#ifdef MIFAREDEBUG
+    PN532DEBUGPRINT.print(F("Trying to write 4 byte page"));
+    PN532DEBUGPRINT.println(page);
+#endif
+
+    /* Prepare the first command */
+    pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE;
+    pn532_packetbuffer[1] = 1; /* Card number */
+    pn532_packetbuffer[2] =
+        MIFARE_ULTRALIGHT_CMD_WRITE; /* Mifare Ultralight Write command = 0xA2
+                                      */
+    pn532_packetbuffer[3] = page;    /* Page Number (0..63 for most cases) */
+    memcpy(pn532_packetbuffer + 4, data, 4); /* Data Payload */
+
+    /* Send the command */
+    if (!sendCommandCheckAck(pn532_packetbuffer, 8)) {
+#ifdef MIFAREDEBUG
+        PN532DEBUGPRINT.println(F("Failed to receive ACK for write command"));
+#endif
+
+        // Return Failed Signal
+        return 0;
+    }
+    delay(10);
+
+    /* Read the response packet */
+    readdata(pn532_packetbuffer, 26);
+
+    // Return OK Signal
+    return 1;
+}
+
+/**************************************************************************/
+/*!
+    Writes an NDEF URI Record starting at the specified page (4..nn)
+
+    Note that this function assumes that the NTAG2xx card is
+    already formatted to work as an "NFC Forum Tag".
+
+    @param  uriIdentifier The uri identifier code (0 = none, 0x01 =
+                          "http://www.", etc.)
+    @param  url           The uri text to write (null-terminated string).
+    @param  dataLen       The size of the data area for overflow checks.
+
+    @returns 1 if everything executed properly, 0 for an error
+*/
+/**************************************************************************/
+uint8_t Adafruit_PN532::ntag2xx_WriteNDEFURI(uint8_t uriIdentifier, char *url,
+                                             uint8_t dataLen) {
+    uint8_t pageBuffer[4] = {0, 0, 0, 0};
+
+    // Remove NDEF record overhead from the URI data (pageHeader below)
+    uint8_t wrapperSize = 12;
+
+    // Figure out how long the string is
+    uint8_t len = strlen(url);
+
+    // Make sure the URI payload will fit in dataLen (include 0xFE trailer)
+    if ((len < 1) || (len + 1 > (dataLen - wrapperSize)))
+        return 0;
+
+    // Setup the record header
+    // See NFCForum-TS-Type-2-Tag_1.1.pdf for details
+    uint8_t pageHeader[12] = {
+        /* NDEF Lock Control TLV (must be first and always present) */
+        0x01, /* Tag Field (0x01 = Lock Control TLV) */
+        0x03, /* Payload Length (always 3) */
+        0xA0, /* The position inside the tag of the lock bytes (upper 4 = page
+                 address, lower 4 = byte offset) */
+        0x10, /* Size in bits of the lock area */
+        0x44, /* Size in bytes of a page and the number of bytes each lock bit
+                 can lock (4 bit + 4 bits) */
+        /* NDEF Message TLV - URI Record */
+        0x03,               /* Tag Field (0x03 = NDEF Message) */
+        (uint8_t)(len + 5), /* Payload Length (not including 0xFE trailer) */
+        0xD1, /* NDEF Record Header (TNF=0x1:Well known record + SR + ME + MB)
+               */
+        0x01, /* Type Length for the record type indicator */
+        (uint8_t)(len + 1), /* Payload len */
+        0x55,         /* Record Type Indicator (0x55 or 'U' = URI Record) */
+        uriIdentifier /* URI Prefix (ex. 0x01 = "http://www.") */
+    };
+
+    // Write 12 byte header (three pages of data starting at page 4)
+    memcpy(pageBuffer, pageHeader, 4);
+    if (!(ntag2xx_WritePage(4, pageBuffer)))
+        return 0;
+    memcpy(pageBuffer, pageHeader + 4, 4);
+    if (!(ntag2xx_WritePage(5, pageBuffer)))
+        return 0;
+    memcpy(pageBuffer, pageHeader + 8, 4);
+    if (!(ntag2xx_WritePage(6, pageBuffer)))
+        return 0;
+
+    // Write URI (starting at page 7)
+    uint8_t currentPage = 7;
+    char *urlcopy = url;
+    while (len) {
+        if (len < 4) {
+            memset(pageBuffer, 0, 4);
+            memcpy(pageBuffer, urlcopy, len);
+            pageBuffer[len] = 0xFE; // NDEF record footer
+            if (!(ntag2xx_WritePage(currentPage, pageBuffer)))
+                return 0;
+            // DONE!
+            return 1;
+        } else if (len == 4) {
+            memcpy(pageBuffer, urlcopy, len);
+            if (!(ntag2xx_WritePage(currentPage, pageBuffer)))
+                return 0;
+            memset(pageBuffer, 0, 4);
+            pageBuffer[0] = 0xFE; // NDEF record footer
+            currentPage++;
+            if (!(ntag2xx_WritePage(currentPage, pageBuffer)))
+                return 0;
+            // DONE!
+            return 1;
+        } else {
+            // More than one page of data left
+            memcpy(pageBuffer, urlcopy, 4);
+            if (!(ntag2xx_WritePage(currentPage, pageBuffer)))
+                return 0;
+            currentPage++;
+            urlcopy += 4;
+            len -= 4;
+        }
+    }
+
+    // Seems that everything was OK (?!)
+    return 1;
+}
+
+/************** high level communication functions (handles both I2C and SPI) */
+
+/**************************************************************************/
+/*!
+    @brief  Tries to read the SPI or I2C ACK signal
+*/
+/**************************************************************************/
+bool Adafruit_PN532::readack() {
+    uint8_t ackbuff[6];
+
+    if (spi_dev) {
+        uint8_t cmd = PN532_SPI_DATAREAD;
+        spi_dev->write_then_read(&cmd, 1, ackbuff, 6);
+    } else if (i2c_dev || ser_dev) {
+        readdata(ackbuff, 6);
+    }
+
+    return (0 == memcmp((char *)ackbuff, (char *)pn532ack, 6));
+}
+
+/**************************************************************************/
+/*!
+    @brief  Return true if the PN532 is ready with a response.
+*/
+/**************************************************************************/
+bool Adafruit_PN532::isready() {
+    if (spi_dev) {
+        // SPI ready check via Status Request
+        uint8_t cmd = PN532_SPI_STATREAD;
+        uint8_t reply;
+        spi_dev->write_then_read(&cmd, 1, &reply, 1);
+        return reply == PN532_SPI_READY;
+    } else if (i2c_dev) {
+        // I2C ready check via reading RDY byte
+        uint8_t rdy[1];
+        i2c_dev->read(rdy, 1);
+        return rdy[0] == PN532_I2C_READY;
+    } else if (ser_dev) {
+        // Serial ready check based on non-zero read buffer
+        return (ser_dev->available() != 0);
+    } else if (_irq != -1) {
+        uint8_t x = digitalRead(_irq);
+        return x == 0;
+    }
+    return false;
+}
+
+/**************************************************************************/
+/*!
+    @brief  Waits until the PN532 is ready.
+
+    @param  timeout   Timeout before giving up
+*/
+/**************************************************************************/
+bool Adafruit_PN532::waitready(uint16_t timeout) {
+    uint16_t timer = 0;
+    while (!isready()) {
+        if (timeout != 0) {
+            timer += 10;
+            if (timer > timeout) {
+#ifdef PN532DEBUG
+                PN532DEBUGPRINT.println("TIMEOUT!");
+#endif
+                return false;
+            }
+        }
+        delay(10);
+    }
+    return true;
+}
+
+/**************************************************************************/
+/*!
+    @brief  Reads n bytes of data from the PN532 via SPI or I2C.
+
+    @param  buff      Pointer to the buffer where data will be written
+    @param  n         Number of bytes to be read
+*/
+/**************************************************************************/
+void Adafruit_PN532::readdata(uint8_t *buff, uint8_t n) {
+    if (spi_dev) {
+        // SPI read
+        uint8_t cmd = PN532_SPI_DATAREAD;
+        spi_dev->write_then_read(&cmd, 1, buff, n);
+    } else if (i2c_dev) {
+        // I2C read
+        uint8_t rbuff[n + 1]; // +1 for leading RDY byte
+        i2c_dev->read(rbuff, n + 1);
+        for (uint8_t i = 0; i < n; i++) {
+            buff[i] = rbuff[i + 1];
+        }
+    } else if (ser_dev) {
+        // Serial read
+        ser_dev->readBytes(buff, n);
+    }
+#ifdef PN532DEBUG
+    PN532DEBUGPRINT.print(F("Reading: "));
+    for (uint8_t i = 0; i < n; i++) {
+        PN532DEBUGPRINT.print(F(" 0x"));
+        PN532DEBUGPRINT.print(buff[i], HEX);
+    }
+    PN532DEBUGPRINT.println();
+#endif
+}
+
+/**************************************************************************/
+/*!
+    @brief   set the PN532 as iso14443a Target behaving as a SmartCard
+    @return  true on success, false otherwise.
+    @note    Author: Salvador Mendoza (salmg.net) new functions:
+             -AsTarget
+             -getDataTarget
+             -setDataTarget
+*/
+/**************************************************************************/
+uint8_t Adafruit_PN532::AsTarget() {
+    pn532_packetbuffer[0] = 0x8C;
+    uint8_t target[] = {
+        0x8C,             // INIT AS TARGET
+        0x00,             // MODE -> BITFIELD
+        0x08, 0x00,       // SENS_RES - MIFARE PARAMS
+        0xdc, 0x44, 0x20, // NFCID1T
+        0x60,             // SEL_RES
+        0x01, 0xfe, // NFCID2T MUST START WITH 01fe - FELICA PARAMS - POL_RES
+        0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xc0,
+        0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, // PAD
+        0xff, 0xff,                               // SYSTEM CODE
+        0xaa, 0x99, 0x88, 0x77, 0x66, 0x55, 0x44,
+        0x33, 0x22, 0x11, 0x01, 0x00, // NFCID3t MAX 47 BYTES ATR_RES
+        0x0d, 0x52, 0x46, 0x49, 0x44, 0x49, 0x4f,
+        0x74, 0x20, 0x50, 0x4e, 0x35, 0x33, 0x32 // HISTORICAL BYTES
+    };
+    if (!sendCommandCheckAck(target, sizeof(target)))
+        return false;
+
+    // read data packet
+    readdata(pn532_packetbuffer, 8);
+
+    int offset = 6;
+    return (pn532_packetbuffer[offset] == 0x15);
+}
+/**************************************************************************/
+/*!
+    @brief   Retrieve response from the emulation mode
+
+    @param   cmd    = data
+    @param   cmdlen = data length
+    @return  true on success, false otherwise.
+*/
+/**************************************************************************/
+uint8_t Adafruit_PN532::getDataTarget(uint8_t *cmd, uint8_t *cmdlen) {
+    uint8_t length;
+    pn532_packetbuffer[0] = 0x86;
+    if (!sendCommandCheckAck(pn532_packetbuffer, 1, 1000)) {
+        PN532DEBUGPRINT.println(F("Error en ack"));
+        return false;
+    }
+
+    // read data packet
+    readdata(pn532_packetbuffer, 64);
+    length = pn532_packetbuffer[3] - 3;
+
+    // if (length > *responseLength) {// Bug, should avoid it in the reading
+    // target data
+    //  length = *responseLength; // silent truncation...
+    //}
+
+    for (int i = 0; i < length; ++i) {
+        cmd[i] = pn532_packetbuffer[8 + i];
+    }
+    *cmdlen = length;
+    return true;
+}
+
+/**************************************************************************/
+/*!
+    @brief   Set data in PN532 in the emulation mode
+
+    @param   cmd    = data
+    @param   cmdlen = data length
+    @return  true on success, false otherwise.
+*/
+/**************************************************************************/
+uint8_t Adafruit_PN532::setDataTarget(uint8_t *cmd, uint8_t cmdlen) {
+    uint8_t length;
+    // cmd1[0] = 0x8E; Must!
+
+    if (!sendCommandCheckAck(cmd, cmdlen))
+        return false;
+
+    // read data packet
+    readdata(pn532_packetbuffer, 8);
+    length = pn532_packetbuffer[3] - 3;
+    for (int i = 0; i < length; ++i) {
+        cmd[i] = pn532_packetbuffer[8 + i];
+    }
+    // cmdl = 0
+    cmdlen = length;
+
+    int offset = 6;
+    return (pn532_packetbuffer[offset] == 0x15);
+}
+
+/**************************************************************************/
+/*!
+    @brief  Writes a command to the PN532, automatically inserting the
+            preamble and required frame details (checksum, len, etc.)
+
+    @param  cmd       Pointer to the command buffer
+    @param  cmdlen    Command length in bytes
+*/
+/**************************************************************************/
+void Adafruit_PN532::writecommand(uint8_t *cmd, uint8_t cmdlen) {
+    if (spi_dev) {
+        // SPI command write.
+        uint8_t checksum;
+        uint8_t packet[9 + cmdlen];
+        uint8_t *p = packet;
+        cmdlen++;
+
+        p[0] = PN532_SPI_DATAWRITE;
+        p++;
+
+        p[0] = PN532_PREAMBLE;
+        p++;
+        p[0] = PN532_STARTCODE1;
+        p++;
+        p[0] = PN532_STARTCODE2;
+        p++;
+        checksum = PN532_PREAMBLE + PN532_STARTCODE1 + PN532_STARTCODE2;
+
+        p[0] = cmdlen;
+        p++;
+        p[0] = ~cmdlen + 1;
+        p++;
+
+        p[0] = PN532_HOSTTOPN532;
+        p++;
+        checksum += PN532_HOSTTOPN532;
+
+        for (uint8_t i = 0; i < cmdlen - 1; i++) {
+            p[0] = cmd[i];
+            p++;
+            checksum += cmd[i];
+        }
+
+        p[0] = ~checksum;
+        p++;
+        p[0] = PN532_POSTAMBLE;
+        p++;
+
+#ifdef PN532DEBUG
+        Serial.print("Sending : ");
+        for (int i = 1; i < 8 + cmdlen; i++) {
+            Serial.print("0x");
+            Serial.print(packet[i], HEX);
+            Serial.print(", ");
+        }
+        Serial.println();
+#endif
+
+        spi_dev->write(packet, 8 + cmdlen);
+    } else if (i2c_dev || ser_dev) {
+        // I2C or Serial command write.
+        uint8_t packet[8 + cmdlen];
+        uint8_t LEN = cmdlen + 1;
+
+        packet[0] = PN532_PREAMBLE;
+        packet[1] = PN532_STARTCODE1;
+        packet[2] = PN532_STARTCODE2;
+        packet[3] = LEN;
+        packet[4] = ~LEN + 1;
+        packet[5] = PN532_HOSTTOPN532;
+        uint8_t sum = 0;
+        for (uint8_t i = 0; i < cmdlen; i++) {
+            packet[6 + i] = cmd[i];
+            sum += cmd[i];
+        }
+        packet[6 + cmdlen] = ~(PN532_HOSTTOPN532 + sum) + 1;
+        packet[7 + cmdlen] = PN532_POSTAMBLE;
+
+#ifdef PN532DEBUG
+        Serial.print("Sending : ");
+        for (int i = 1; i < 8 + cmdlen; i++) {
+            Serial.print("0x");
+            Serial.print(packet[i], HEX);
+            Serial.print(", ");
+        }
+        Serial.println();
+#endif
+
+        if (i2c_dev) {
+            i2c_dev->write(packet, 8 + cmdlen);
+        } else {
+            ser_dev->write(packet, 8 + cmdlen);
+        }
+    }
+}