/**************************************************************************/ /*! @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 240 ///< Packet buffer size in bytes byte pn532_packetbuffer[PN532_PACKBUFFSIZ]; ///< Packet buffer used in various ///< transactions Adafruit_PN532::Adafruit_PN532() {} /**************************************************************************/ /*! @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 Set PN532 class to use 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) */ /**************************************************************************/ void Adafruit_PN532::setInterface(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 Set PN532 class to use I2C. @param theWire pointer to I2C bus to use */ /**************************************************************************/ void Adafruit_PN532::setInterface(uint8_t sdaPin, uint8_t sclPin) { i2c_dev = new Adafruit_I2CDevice(PN532_I2C_ADDRESS, sdaPin, sclPin); } /**************************************************************************/ /*! @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 = 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); } bool Adafruit_PN532::powerDown() { pn532_packetbuffer[0] = PN532_COMMAND_POWERDOWN; pn532_packetbuffer[1] = 0xC0; // I2C or SPI Wakeup pn532_packetbuffer[2] = 0x00; // no IRQ return sendCommandCheckAck(pn532_packetbuffer, 3); } /**************************************************************************/ /*! 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; } /**************************************************************************/ /*! Reads the ID of the passive target the reader has deteceted. @returns 1 if everything executed properly, 0 for an error */ /**************************************************************************/ bool Adafruit_PN532::readDetectedPassiveTargetID() { // 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; for (int i = 0; i < 2; i++) targetUid.atqaByte[i] = pn532_packetbuffer[9 + i]; targetUid.sak = pn532_packetbuffer[11]; targetUid.size = pn532_packetbuffer[12]; for (uint8_t i = 0; i < pn532_packetbuffer[12]; i++) { targetUid.uidByte[i] = pn532_packetbuffer[13 + i]; } #ifdef MIFAREDEBUG PN532DEBUGPRINT.print(F("ATQA:")); for (uint8_t i = 0; i < 2; i++) { PN532DEBUGPRINT.print(F(" 0x")); PN532DEBUGPRINT.print(targetUid.atqaByte[i], HEX); } PN532DEBUGPRINT.print(F("SAK: 0x")); PN532DEBUGPRINT.println(targetUid.sak, HEX); PN532DEBUGPRINT.print(F("UID:")); for (uint8_t i = 0; i < targetUid.size; i++) { PN532DEBUGPRINT.print(F(" 0x")); PN532DEBUGPRINT.print(targetUid.uidByte[i], HEX); } PN532DEBUGPRINT.println(); #endif return 1; } String Adafruit_PN532::PICC_GetTypeName(byte sak) { if (sak & 0x04) { // UID not complete return "SAK indicates UID is not complete."; } switch (sak) { case 0x09: return "MIFARE Mini, 320 bytes"; break; case 0x08: return "MIFARE 1KB"; break; case 0x18: return "MIFARE 4KB"; break; case 0x00: return "MIFARE Ultralight or Ultralight C"; break; case 0x10: case 0x11: return "MIFARE Plus"; break; case 0x01: return "MIFARE TNP3XXX"; break; default: break; } if (sak & 0x20) { return "PICC compliant with ISO/IEC 14443-4"; } if (sak & 0x40) { return "PICC compliant with ISO/IEC 18092 (NFC)"; } return "Unknown type"; } /**************************************************************************/ /*! @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; } /********************************************************************/ /*! * @brief 'TgInitAsTarget' is used to configure a PN532 as a tag by the host. * */ /********************************************************************/ bool Adafruit_PN532::TgInitAsTarget() { uint8_t cmd[] = { PN532_COMMAND_TGINITASTARGET, 0x05, // MODE: PICC only, Passive only 0x04, 0x00, // SENS_RES 0x12, 0x34, 0x56, // NFCID1 0x20, // SEL_RES 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // FeliCaParams 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // NFCID3t 0, // length of general bytes 0 // length of historical bytes }; if (!sendCommandCheckAck(cmd, sizeof(cmd), 1000)) { #ifdef PN532DEBUG PN532DEBUGPRINT.print(F("Failed at sendCommandCheckAck command")); #endif return false; } if (!waitready(1000)) { #ifdef PN532DEBUG PN532DEBUGPRINT.println(F("Response never received for ADPU...")); #endif return false; } readdata(pn532_packetbuffer, sizeof(pn532_packetbuffer)); return pn532_packetbuffer[7] == 0x08; } /**************************************************************************/ /*! @brief Gets an APDU from the currently inlisted peer @param response Pointer to response data @param responseLength Pointer to the response data length */ /**************************************************************************/ bool Adafruit_PN532::TgGetData(uint8_t * response, uint8_t * responseLength) { pn532_packetbuffer[0] = PN532_COMMAND_TGGETDATA; // 0x86 if (!sendCommandCheckAck(pn532_packetbuffer, 1, 1000)) { #ifdef PN532DEBUG PN532DEBUGPRINT.println(F("Failed at sendCommandCheckAck")); #endif return false; } if (!waitready(1000)) { #ifdef PN532DEBUG PN532DEBUGPRINT.println(F("Response never received for ADPU...")); #endif return false; } readdata(pn532_packetbuffer, sizeof(pn532_packetbuffer)); #ifdef PN532DEBUG PN532DEBUGPRINT.print(F("Received Packetbuffer: ")); PrintHex(pn532_packetbuffer, sizeof(pn532_packetbuffer)); #endif *responseLength = pn532_packetbuffer[3]-3; for(uint8_t i=0; i<*responseLength; i++) { response[i] = pn532_packetbuffer[i+8]; } #ifdef PN532DEBUG PN532DEBUGPRINT.print(F("Received GetData Packet: ")); PrintHex(response, *responseLength); #endif return pn532_packetbuffer[7] == 0x00; } /**************************************************************************/ /*! @brief Sends an APDU to the currently inlisted peer @param send Pointer to data to send @param sendLength Length of the data to send */ /**************************************************************************/ bool Adafruit_PN532::TgSetData(uint8_t * send, uint8_t sendLength) { pn532_packetbuffer[0] = PN532_COMMAND_TGSETDATA; //0x8E for (uint8_t i=0; i 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, 16); } 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; } /***** Felica Functions ******/ /**************************************************************************/ /*! @brief Poll FeliCa card. PN532 acting as reader/initiator, peer acting as card/responder. @param[in] systemCode Designation of System Code. When sending FFFFh as System Code, all FeliCa cards can return response. @param[in] requestCode Designation of Request Data as follows: 00h: No Request 01h: System Code request (to acquire System Code of the card) 02h: Communication perfomance request @param[out] idm IDm of the card (8 bytes) @param[out] pmm PMm of the card (8 bytes) @param[out] systemCodeResponse System Code of the card (Optional, 2bytes) @param[in] timeout Timeout for every command @return = 1: A FeliCa card has detected = 0: No card has detected */ /**************************************************************************/ uint8_t Adafruit_PN532::felica_Polling(uint16_t systemCode, uint8_t requestCode, uint8_t *idm, uint8_t *pmm, uint16_t *systemCodeResponse, uint16_t timeout) { pn532_packetbuffer[0] = PN532_COMMAND_INLISTPASSIVETARGET; pn532_packetbuffer[1] = 1; pn532_packetbuffer[2] = 1; pn532_packetbuffer[3] = FELICA_CMD_POLLING; pn532_packetbuffer[4] = (systemCode >> 8) & 0xFF; pn532_packetbuffer[5] = systemCode & 0xFF; pn532_packetbuffer[6] = requestCode; pn532_packetbuffer[7] = 0; if (!sendCommandCheckAck(pn532_packetbuffer, 8, timeout)) { #ifdef PN532DEBUG PN532DEBUGPRINT.println("Error sending command"); #endif return 0; } /* Response structure: 0-9 not used 10 response code(should be 01) 11-19 IDm 19-27 PMm 27-29 Request data(only when request code is not 0x00 and supported by card) */ readdata(pn532_packetbuffer, requestCode == 0x01 ? 29 : 27); #ifdef PN532DEBUG PrintHex(pn532_packetbuffer, requestCode == 0x01 ? 29 : 27); #endif if ((sizeof(pn532_packetbuffer) / sizeof(byte)) == 0) { #ifdef PN532DEBUG PN532DEBUGPRINT.println("Could not receive response"); #endif return 0; } // Check for Response code == 0x01 if (pn532_packetbuffer[10] != 0x01) { #ifdef PN532DEBUG PN532DEBUGPRINT.println("No card had detected"); #endif return 0; } _inListedTag = pn532_packetbuffer[8]; // Fill data memcpy(idm, &pn532_packetbuffer[11], 8); memcpy(_felicaIDm, &pn532_packetbuffer[11], 8); memcpy(pmm, &pn532_packetbuffer[19], 8); memcpy(_felicaPMm, &pn532_packetbuffer[19], 8); if (requestCode == 0x01) *systemCodeResponse = (pn532_packetbuffer[27] << 8) + pn532_packetbuffer[28]; return 1; } /**************************************************************************/ /*! @brief Sends FeliCa command to the currently inlisted peer and get response in buffer @param[in] command FeliCa command packet. (e.g. 00 FF FF 00 00 for Polling command) @param[in] commandlength Length of the FeliCa command packet. (e.g. 0x05 for above Polling command ) @param[out] responseLength Length of the FeliCa response packet. (e.g. 0x11 for above Polling command ) @return = 1: Success = 0: error */ /**************************************************************************/ uint8_t Adafruit_PN532::felica_SendCommand(const uint8_t *command, uint8_t commandlength, uint8_t responseLength) { if (commandlength > 0xFE) { #ifdef PN532DEBUG PN532DEBUGPRINT.println("Command length too long"); #endif return -1; } pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE; pn532_packetbuffer[1] = _inListedTag; pn532_packetbuffer[2] = commandlength + 1; memcpy(&pn532_packetbuffer[3], command, commandlength); if (!sendCommandCheckAck(pn532_packetbuffer, 3 + commandlength)) { #ifdef PN532DEBUG PN532DEBUGPRINT.println("Could not send FeliCa command"); #endif return 0; } /* Read data in packet buffer */ readdata(pn532_packetbuffer, responseLength); return 1; } /**************************************************************************/ /*! @brief Sends FeliCa Read Without Encryption command @param[in] numService Length of the serviceCodeList @param[in] serviceCodeList Service Code List (Big Endian) @param[in] numBlock Length of the blockList @param[in] blockList Block List (Big Endian, This API only accepts 2-byte block list element) @param[out] blockData Block Data @return = 1: Success = 0: error */ /**************************************************************************/ uint8_t Adafruit_PN532::felica_ReadWithoutEncryption( uint8_t numService, const uint16_t *serviceCodeList, uint8_t numBlock, const uint16_t *blockList, uint8_t blockData[][16]) { if (numService > FELICA_READ_MAX_SERVICE_NUM) { #ifdef PN532DEBUG PN532DEBUGPRINT.println("numService is too large"); #endif return 0; } if (numBlock > FELICA_READ_MAX_BLOCK_NUM) { #ifdef PN532DEBUG PN532DEBUGPRINT.println("numBlock is too large"); #endif return 0; } uint8_t i; uint8_t cmdLen = 1 + 8 + 1 + 2 * numService + 1 + 2 * numBlock; uint8_t cmd[cmdLen]; cmd[0] = FELICA_CMD_READ_WITHOUT_ENCRYPTION; memcpy(&cmd[1], _felicaIDm, 8); // Fill card IDm /* Fill number of service and service code list */ cmd[9] = numService; int j = 10; for (i = 0; i < numService; ++i) { cmd[j++] = serviceCodeList[i] & 0xFF; cmd[j++] = (serviceCodeList[i] >> 8) & 0xff; } /* Fill number of block and blocklist */ cmd[j++] = numBlock; for (i = 0; i < numBlock; ++i) { cmd[j++] = (blockList[i] >> 8) & 0xFF; cmd[j++] = blockList[i] & 0xff; } const uint8_t responseLength = 20 + 16 * numBlock; if (felica_SendCommand(cmd, cmdLen, responseLength) != 1) { #ifdef PN532DEBUG PN532DEBUGPRINT.println("Read Without Encryption command failed"); #endif return 0; } if (pn532_packetbuffer[9] != 0x07) { #ifdef PN532DEBUG PN532DEBUGPRINT.println("Invalid response"); #endif return 0; } if (pn532_packetbuffer[18] != 0x00) { #ifdef PN532DEBUG PN532DEBUGPRINT.println("Invalid status flag"); #endif return 0; } /* Copy block data from buffer to blockData parameter */ for (size_t i = 0; i < numBlock; i++) { memcpy(blockData[i], &pn532_packetbuffer[(21 * i) + 21], 16); } return 1; } /**************************************************************************/ /*! @brief Sends FeliCa Write Without Encryption command @param[in] numService Length of the serviceCodeList @param[in] serviceCodeList Service Code List (Big Endian) @param[in] numBlock Length of the blockList @param[in] blockList Block List (Big Endian, This API only accepts 2-byte block list element) @param[in] blockData Block Data (each Block has 16 bytes) @return = 1: Success = 0: error */ /**************************************************************************/ uint8_t Adafruit_PN532::felica_WriteWithoutEncryption( uint8_t numService, const uint16_t *serviceCodeList, uint8_t numBlock, const uint16_t *blockList, uint8_t blockData[][16]) { if (numService > FELICA_WRITE_MAX_SERVICE_NUM) { #ifdef PN532DEBUG PN532DEBUGPRINT.println("numService is too large"); #endif return 0; } if (numBlock > FELICA_WRITE_MAX_BLOCK_NUM) { #ifdef PN532DEBUG PN532DEBUGPRINT.println("numBlock is too large"); #endif return 0; } uint8_t i, k; uint8_t cmdLen = 1 + 8 + 1 + 2 * numService + 1 + 2 * numBlock + 16 * numBlock; uint8_t cmd[cmdLen]; cmd[0] = FELICA_CMD_WRITE_WITHOUT_ENCRYPTION; memcpy(&cmd[1], _felicaIDm, 8); // Fill card IDm int j = 10; cmd[j++] = numService; for (i = 0; i < numService; ++i) { cmd[j++] = serviceCodeList[i] & 0xFF; cmd[j++] = (serviceCodeList[i] >> 8) & 0xff; } cmd[j++] = numBlock; for (i = 0; i < numBlock; ++i) { cmd[j++] = (blockList[i] >> 8) & 0xFF; cmd[j++] = blockList[i] & 0xff; } for (i = 0; i < numBlock; ++i) { for (k = 0; k < 16; k++) { cmd[j++] = blockData[i][k]; } } if (felica_SendCommand(cmd, cmdLen, 11) != 1) { #ifdef PN532DEBUG PN532DEBUGPRINT.println("Write Without Encryption command failed"); #endif return 0; } if (pn532_packetbuffer[9] != 0x09) { #ifdef PN532DEBUG PN532DEBUGPRINT.printf("Response code doesn't match. Status: %i\n", pn532_packetbuffer[9]); #endif return 0; } return 1; } /**************************************************************************/ /*! @brief Release FeliCa card @return = 1: Success = 0: error */ /**************************************************************************/ uint8_t Adafruit_PN532::felica_Release() { // InRelease pn532_packetbuffer[0] = PN532_COMMAND_INRELEASE; pn532_packetbuffer[1] = 0x00; // All target #ifdef PN532DEBUG PN532DEBUGPRINT.println("Release all FeliCa target"); #endif if (sendCommandCheckAck(pn532_packetbuffer, 2)) { #ifdef PN532DEBUG PN532DEBUGPRINT.println("No ACK"); #endif return 0; // no ACK } 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); } } } /**************************************************************************/ /*! @brief Builds the command to send to write to the PN532 registers @param reg Pointer to the command buffer, goes in the form of ADDR1H ADDR1L VAL1...ADDRnH ADDRnL VALn @param len Command length in bytes */ /**************************************************************************/ bool Adafruit_PN532::WriteRegister(uint8_t *reg, uint8_t len) { uint8_t cmd[len + 1]; uint8_t result[8]; cmd[0] = PN532_COMMAND_WRITEREGISTER; for (uint8_t i = 0; i < len; i++) { cmd[i + 1] = reg[i]; } if (!sendCommandCheckAck(cmd, len + 1)) return false; readdata(result, 8); return true; } /**************************************************************************/ /*! @brief Builds the command to send commands directly to the PICC Works like inDataExchange but doesn't handles all the protocol features @param data Pointer to the command buffer @param len Command length in bytes */ /**************************************************************************/ bool Adafruit_PN532::InCommunicateThru(uint8_t *data, uint8_t len) { uint8_t cmd[len + 1]; uint8_t result[8]; cmd[0] = PN532_COMMAND_INCOMMUNICATETHRU; for (uint8_t i = 0; i < len; i++) { cmd[i + 1] = data[i]; } if (!sendCommandCheckAck(cmd, len + 1)) return false; readdata(result, 8); // If byte 8 isn't 0x00 we probably have an error, if (result[7] != 0x00) return false; return true; } /**************************************************************************/ /*! @brief Performs the command sequence in some chinese MiFare Classic tags that unlocks a special backdoor to perform write/read commands without authentication >HALT + CRC (50 00 57 CD) >UNLOCK1 (40) 7 bits UNLOCK2 (43)