pn532.h

/*
 * Author: Jon Trulson <jtrulson@ics.com>
 * Copyright (c) 2015 Intel Corporation.
 *
 * This code is heavily based on the Adafruit-PN532 library at
 * https://github.com/adafruit/Adafruit-PN532, which is licensed under
 * the BSD license. See upm/src/pn532/license.txt
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
  

#pragma once

#include <string.h>
#include <string>
#include <mraa/common.hpp>
#include <mraa/i2c.hpp>

#include <mraa/gpio.hpp>

#define PN532_I2C_BUS 0
#define PN532_DEFAULT_I2C_ADDR (0x48 >> 1)

#define PN532_PREAMBLE                      (0x00)
#define PN532_STARTCODE1                    (0x00)
#define PN532_STARTCODE2                    (0xFF)
#define PN532_POSTAMBLE                     (0x00)

#define PN532_HOSTTOPN532                   (0xD4)
#define PN532_PN532TOHOST                   (0xD5)

namespace upm {
  
  class PN532 {
  public:

    typedef enum {
      CMD_DIAGNOSE              = 0x00,
      CMD_GETFIRMWAREVERSION    = 0x02,
      CMD_GETGENERALSTATUS      = 0x04,
      CMD_READREGISTER          = 0x06,
      CMD_WRITEREGISTER         = 0x08,
      CMD_READGPIO              = 0x0C,
      CMD_WRITEGPIO             = 0x0E,
      CMD_SETSERIALBAUDRATE     = 0x10,
      CMD_SETPARAMETERS         = 0x12,
      CMD_SAMCONFIGURATION      = 0x14,
      CMD_POWERDOWN             = 0x16,
      CMD_RFCONFIGURATION       = 0x32,
      CMD_RFREGULATIONTEST      = 0x58,
      CMD_INJUMPFORDEP          = 0x56,
      CMD_INJUMPFORPSL          = 0x46,
      CMD_INLISTPASSIVETARGET   = 0x4A,
      CMD_INATR                 = 0x50,
      CMD_INPSL                 = 0x4E,
      CMD_INDATAEXCHANGE        = 0x40,
      CMD_INCOMMUNICATETHRU     = 0x42,
      CMD_INDESELECT            = 0x44,
      CMD_INRELEASE             = 0x52,
      CMD_INSELECT              = 0x54,
      CMD_INAUTOPOLL            = 0x60,
      CMD_TGINITASTARGET        = 0x8C,
      CMD_TGSETGENERALBYTES     = 0x92,
      CMD_TGGETDATA             = 0x86,
      CMD_TGSETDATA             = 0x8E,
      CMD_TGSETMETADATA         = 0x94,
      CMD_TGGETINITIATORCOMMAND = 0x88,
      CMD_TGRESPONSETOINITIATOR = 0x90,
      CMD_TGGETTARGETSTATUS     = 0x8A
    } PN532_CMD_T;
    
    typedef enum {
      RSP_INDATAEXCHANGE        = 0x41,
      RSP_INLISTPASSIVETARGET   = 0x4B
    } PN532_RSP_T;

    typedef enum {
      MIFARE_CMD_AUTH_A                   = 0x60,
      MIFARE_CMD_AUTH_B                   = 0x61,
      MIFARE_CMD_READ                     = 0x30,
      MIFARE_CMD_WRITE                    = 0xA0,
      MIFARE_CMD_TRANSFER                 = 0xB0,
      MIFARE_CMD_DECREMENT                = 0xC0,
      MIFARE_CMD_INCREMENT                = 0xC1,
      MIFARE_CMD_STORE                    = 0xC2,
      MIFARE_ULTRALIGHT_CMD_WRITE         = 0xA2
    } MIFARE_CMD_T;

    typedef enum {
      NDEF_URIPREFIX_NONE                 = 0x00,
      NDEF_URIPREFIX_HTTP_WWWDOT          = 0x01,
      NDEF_URIPREFIX_HTTPS_WWWDOT         = 0x02,
      NDEF_URIPREFIX_HTTP                 = 0x03,
      NDEF_URIPREFIX_HTTPS                = 0x04,
      NDEF_URIPREFIX_TEL                  = 0x05,
      NDEF_URIPREFIX_MAILTO               = 0x06,
      NDEF_URIPREFIX_FTP_ANONAT           = 0x07,
      NDEF_URIPREFIX_FTP_FTPDOT           = 0x08,
      NDEF_URIPREFIX_FTPS                 = 0x09,
      NDEF_URIPREFIX_SFTP                 = 0x0A,
      NDEF_URIPREFIX_SMB                  = 0x0B,
      NDEF_URIPREFIX_NFS                  = 0x0C,
      NDEF_URIPREFIX_FTP                  = 0x0D,
      NDEF_URIPREFIX_DAV                  = 0x0E,
      NDEF_URIPREFIX_NEWS                 = 0x0F,
      NDEF_URIPREFIX_TELNET               = 0x10,
      NDEF_URIPREFIX_IMAP                 = 0x11,
      NDEF_URIPREFIX_RTSP                 = 0x12,
      NDEF_URIPREFIX_URN                  = 0x13,
      NDEF_URIPREFIX_POP                  = 0x14,
      NDEF_URIPREFIX_SIP                  = 0x15,
      NDEF_URIPREFIX_SIPS                 = 0x16,
      NDEF_URIPREFIX_TFTP                 = 0x17,
      NDEF_URIPREFIX_BTSPP                = 0x18,
      NDEF_URIPREFIX_BTL2CAP              = 0x19,
      NDEF_URIPREFIX_BTGOEP               = 0x1A,
      NDEF_URIPREFIX_TCPOBEX              = 0x1B,
      NDEF_URIPREFIX_IRDAOBEX             = 0x1C,
      NDEF_URIPREFIX_FILE                 = 0x1D,
      NDEF_URIPREFIX_URN_EPC_ID           = 0x1E,
      NDEF_URIPREFIX_URN_EPC_TAG          = 0x1F,
      NDEF_URIPREFIX_URN_EPC_PAT          = 0x20,
      NDEF_URIPREFIX_URN_EPC_RAW          = 0x21,
      NDEF_URIPREFIX_URN_EPC              = 0x22,
      NDEF_URIPREFIX_URN_NFC              = 0x23
    } NDEF_URI_T;

    typedef enum {
      BAUD_MIFARE_ISO14443A               = 0x00 // 106 Kbit/s
    } BAUD_T;


    typedef enum {
      TAG_TYPE_UNKNOWN                    = 0,
      TAG_TYPE_MIFARE_CLASSIC             = 1,
      TAG_TYPE_NFC2                       = 2 /* ultralight or NTAG2XX */
    } TAG_TYPE_T;

    PN532(int irq, int reset, int bus=PN532_I2C_BUS, 
          uint8_t address=PN532_DEFAULT_I2C_ADDR);

    ~PN532();
    
    bool init();

    uint32_t getFirmwareVersion();

    bool sendCommandCheckAck(uint8_t *cmd, uint8_t cmdlen, 
                             uint16_t timeout=1000);

    bool SAMConfig(void);

    bool setPassiveActivationRetries(uint8_t maxRetries);
 
    bool readPassiveTargetID(BAUD_T cardbaudrate, uint8_t * uid, 
                             uint8_t * uidLength, uint16_t timeout);
    
    bool inDataExchange(uint8_t * send, uint8_t sendLength,
                        uint8_t * response, uint8_t * responseLength);

    bool inListPassiveTarget();

    bool mifareclassic_IsFirstBlock (uint32_t uiBlock);

    bool mifareclassic_IsTrailerBlock (uint32_t uiBlock);

    bool mifareclassic_AuthenticateBlock (uint8_t * uid, uint8_t uidLen,
                                          uint32_t blockNumber,
                                          uint8_t keyNumber,
                                          uint8_t * keyData);

    bool mifareclassic_ReadDataBlock (uint8_t blockNumber, uint8_t * data);

    bool mifareclassic_WriteDataBlock (uint8_t blockNumber, uint8_t * data);

    bool mifareclassic_FormatNDEF (void);

    bool mifareclassic_WriteNDEFURI (uint8_t sectorNumber, 
                                     NDEF_URI_T uriIdentifier,
                                     const char * url);

    bool ntag2xx_ReadPage (uint8_t page, uint8_t * buffer);

    bool ntag2xx_WritePage (uint8_t page, uint8_t * data);

    bool ntag2xx_WriteNDEFURI (NDEF_URI_T uriIdentifier, char * url, 
                               uint8_t dataLen);

    uint16_t getATQA() { return m_ATQA; };

    uint8_t getSAK() { return m_SAK; };

    mraa::I2c& i2cContext() { return m_i2c; };

    void pn532Debug(bool enable) { m_pn532Debug = enable; };

    void mifareDebug(bool enable) { m_mifareDebug = enable; };

    TAG_TYPE_T tagType();

  protected:
    mraa::I2c m_i2c;
    mraa::Gpio m_gpioIRQ;
    mraa::Gpio m_gpioReset;

    bool readAck();
    bool isReady();
    bool waitForReady(uint16_t timeout);
    void readData(uint8_t* buff, uint8_t n);
    void writeCommand(uint8_t* cmd, uint8_t cmdlen);

  private:
    static void dataReadyISR(void *ctx);
    bool m_isrInstalled;
    volatile bool m_irqRcvd;

    uint8_t m_addr;

    uint8_t m_uid[7];       // ISO14443A uid
    uint8_t m_uidLen;       // uid len
    uint8_t m_key[6];       // Mifare Classic key
    uint8_t m_inListedTag;  // Tg number of inlisted tag.

    uint16_t m_ATQA;        // ATQA (Answer to Request Acknowlege - ISO14443)
                            // for currently inlisted card
    uint8_t m_SAK;          // SAK (Select Acknowlege) 
                            // for currently inlisted card

    // debugables
    bool m_pn532Debug;
    bool m_mifareDebug;
  };
}