1823 lines
57 KiB
C++
1823 lines
57 KiB
C++
/**************************************************************************/
|
|
/*!
|
|
@file Adafruit_PN532.cpp
|
|
|
|
Forked from https://github.com/adafruit/Adafruit-PN532 on 2023-04-21 to add FeliCa support
|
|
|
|
@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)
|
|
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);
|
|
}
|
|
}
|
|
}
|