Big revision

Everything rewritten in C/C++ Customized version of Seed Studio's PN532 NFC Library

Big revision
Everything rewritten in C/C++ Customized version of Seed Studio's PN532 NFC Library
henyxia
1 parent aff6dccd
Showing 38 changed files with 5069 additions and 44 deletions Show diff stats
Arduino/pins_arduino.h
Arduino/wiring.c
Arduino/wiring_digital.c
Arduino/wiring_private.h
Makefile
PN532/PN532.cpp
PN532/PN532.h
PN532/PN532Interface.h
PN532/PN532_debug.h
PN532/README.md
PN532/SPI.cpp
PN532/SPI.h
PN532/emulatetag.cpp
PN532/emulatetag.h
PN532/examples/android_hce/android_hce.ino
PN532/examples/emulate_tag_ndef/emulate_tag_ndef.ino
PN532/examples/iso14443a_uid/iso14443a_uid.pde
PN532/examples/mifareclassic_formatndef/mifareclassic_formatndef.pde
PN532/examples/mifareclassic_memdump/mifareclassic_memdump.pde
PN532/examples/mifareclassic_ndeftoclassic/mifareclassic_ndeftoclassic.pde
@@ -0,0 +1,218 @@
+/*
+  pins_arduino.h - Pin definition functions for Arduino
+  Part of Arduino - http://www.arduino.cc/
+
+  Copyright (c) 2007 David A. Mellis
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+
+  $Id: wiring.h 249 2007-02-03 16:52:51Z mellis $
+*/
+
+#ifndef Pins_Arduino_h
+#define Pins_Arduino_h
+
+#include <avr/pgmspace.h>
+
+#define NUM_DIGITAL_PINS            20
+#define NUM_ANALOG_INPUTS           6
+#define analogInputToDigitalPin(p)  ((p < 6) ? (p) + 14 : -1)
+
+#if defined(__AVR_ATmega8__)
+#define digitalPinHasPWM(p)         ((p) == 9 || (p) == 10 || (p) == 11)
+#else
+#define digitalPinHasPWM(p)         ((p) == 3 || (p) == 5 || (p) == 6 || (p) == 9 || (p) == 10 || (p) == 11)
+#endif
+
+static const uint8_t SS   = 10;
+static const uint8_t MOSI = 11;
+static const uint8_t MISO = 12;
+static const uint8_t SCK  = 13;
+
+static const uint8_t SDA = 18;
+static const uint8_t SCL = 19;
+static const uint8_t LED_BUILTIN = 13;
+
+static const uint8_t A0 = 14;
+static const uint8_t A1 = 15;
+static const uint8_t A2 = 16;
+static const uint8_t A3 = 17;
+static const uint8_t A4 = 18;
+static const uint8_t A5 = 19;
+static const uint8_t A6 = 20;
+static const uint8_t A7 = 21;
+
+#define digitalPinToPCICR(p)    (((p) >= 0 && (p) <= 21) ? (&PCICR) : ((uint8_t *)0))
+#define digitalPinToPCICRbit(p) (((p) <= 7) ? 2 : (((p) <= 13) ? 0 : 1))
+#define digitalPinToPCMSK(p)    (((p) <= 7) ? (&PCMSK2) : (((p) <= 13) ? (&PCMSK0) : (((p) <= 21) ? (&PCMSK1) : ((uint8_t *)0))))
+#define digitalPinToPCMSKbit(p) (((p) <= 7) ? (p) : (((p) <= 13) ? ((p) - 8) : ((p) - 14)))
+
+#ifdef ARDUINO_MAIN
+
+// On the Arduino board, digital pins are also used
+// for the analog output (software PWM).  Analog input
+// pins are a separate set.
+
+// ATMEL ATMEGA8 & 168 / ARDUINO
+//
+//                  +-\/-+
+//            PC6  1|    |28  PC5 (AI 5)
+//      (D 0) PD0  2|    |27  PC4 (AI 4)
+//      (D 1) PD1  3|    |26  PC3 (AI 3)
+//      (D 2) PD2  4|    |25  PC2 (AI 2)
+// PWM+ (D 3) PD3  5|    |24  PC1 (AI 1)
+//      (D 4) PD4  6|    |23  PC0 (AI 0)
+//            VCC  7|    |22  GND
+//            GND  8|    |21  AREF
+//            PB6  9|    |20  AVCC
+//            PB7 10|    |19  PB5 (D 13)
+// PWM+ (D 5) PD5 11|    |18  PB4 (D 12)
+// PWM+ (D 6) PD6 12|    |17  PB3 (D 11) PWM
+//      (D 7) PD7 13|    |16  PB2 (D 10) PWM
+//      (D 8) PB0 14|    |15  PB1 (D 9) PWM
+//                  +----+
+//
+// (PWM+ indicates the additional PWM pins on the ATmega168.)
+
+// ATMEL ATMEGA1280 / ARDUINO
+//
+// 0-7 PE0-PE7   works
+// 8-13 PB0-PB5  works
+// 14-21 PA0-PA7 works 
+// 22-29 PH0-PH7 works
+// 30-35 PG5-PG0 works
+// 36-43 PC7-PC0 works
+// 44-51 PJ7-PJ0 works
+// 52-59 PL7-PL0 works
+// 60-67 PD7-PD0 works
+// A0-A7 PF0-PF7
+// A8-A15 PK0-PK7
+
+
+// these arrays map port names (e.g. port B) to the
+// appropriate addresses for various functions (e.g. reading
+// and writing)
+const uint16_t PROGMEM port_to_mode_PGM[] = {
+	NOT_A_PORT,
+	NOT_A_PORT,
+	(uint16_t) &DDRB,
+	(uint16_t) &DDRC,
+	(uint16_t) &DDRD,
+};
+
+const uint16_t PROGMEM port_to_output_PGM[] = {
+	NOT_A_PORT,
+	NOT_A_PORT,
+	(uint16_t) &PORTB,
+	(uint16_t) &PORTC,
+	(uint16_t) &PORTD,
+};
+
+const uint16_t PROGMEM port_to_input_PGM[] = {
+	NOT_A_PORT,
+	NOT_A_PORT,
+	(uint16_t) &PINB,
+	(uint16_t) &PINC,
+	(uint16_t) &PIND,
+};
+
+const uint8_t PROGMEM digital_pin_to_port_PGM[] = {
+	PD, /* 0 */
+	PD,
+	PD,
+	PD,
+	PD,
+	PD,
+	PD,
+	PD,
+	PB, /* 8 */
+	PB,
+	PB,
+	PB,
+	PB,
+	PB,
+	PC, /* 14 */
+	PC,
+	PC,
+	PC,
+	PC,
+	PC,
+};
+
+const uint8_t PROGMEM digital_pin_to_bit_mask_PGM[] = {
+	_BV(0), /* 0, port D */
+	_BV(1),
+	_BV(2),
+	_BV(3),
+	_BV(4),
+	_BV(5),
+	_BV(6),
+	_BV(7),
+	_BV(0), /* 8, port B */
+	_BV(1),
+	_BV(2),
+	_BV(3),
+	_BV(4),
+	_BV(5),
+	_BV(0), /* 14, port C */
+	_BV(1),
+	_BV(2),
+	_BV(3),
+	_BV(4),
+	_BV(5),
+};
+
+const uint8_t PROGMEM digital_pin_to_timer_PGM[] = {
+	NOT_ON_TIMER, /* 0 - port D */
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	// on the ATmega168, digital pin 3 has hardware pwm
+#if defined(__AVR_ATmega8__)
+	NOT_ON_TIMER,
+#else
+	TIMER2B,
+#endif
+	NOT_ON_TIMER,
+	// on the ATmega168, digital pins 5 and 6 have hardware pwm
+#if defined(__AVR_ATmega8__)
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+#else
+	TIMER0B,
+	TIMER0A,
+#endif
+	NOT_ON_TIMER,
+	NOT_ON_TIMER, /* 8 - port B */
+	TIMER1A,
+	TIMER1B,
+#if defined(__AVR_ATmega8__)
+	TIMER2,
+#else
+	TIMER2A,
+#endif
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	NOT_ON_TIMER, /* 14 - port C */
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+};
+
+#endif
+
+#endif
@@ -0,0 +1,324 @@
+/*
+  wiring.c - Partial implementation of the Wiring API for the ATmega8.
+  Part of Arduino - http://www.arduino.cc/
+
+  Copyright (c) 2005-2006 David A. Mellis
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+
+  $Id$
+*/
+
+#include "wiring_private.h"
+
+// the prescaler is set so that timer0 ticks every 64 clock cycles, and the
+// the overflow handler is called every 256 ticks.
+#define MICROSECONDS_PER_TIMER0_OVERFLOW (clockCyclesToMicroseconds(64 * 256))
+
+// the whole number of milliseconds per timer0 overflow
+#define MILLIS_INC (MICROSECONDS_PER_TIMER0_OVERFLOW / 1000)
+
+// the fractional number of milliseconds per timer0 overflow. we shift right
+// by three to fit these numbers into a byte. (for the clock speeds we care
+// about - 8 and 16 MHz - this doesn't lose precision.)
+#define FRACT_INC ((MICROSECONDS_PER_TIMER0_OVERFLOW % 1000) >> 3)
+#define FRACT_MAX (1000 >> 3)
+
+volatile unsigned long timer0_overflow_count = 0;
+volatile unsigned long timer0_millis = 0;
+static unsigned char timer0_fract = 0;
+
+#if defined(__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
+ISR(TIM0_OVF_vect)
+#else
+ISR(TIMER0_OVF_vect)
+#endif
+{
+	// copy these to local variables so they can be stored in registers
+	// (volatile variables must be read from memory on every access)
+	unsigned long m = timer0_millis;
+	unsigned char f = timer0_fract;
+
+	m += MILLIS_INC;
+	f += FRACT_INC;
+	if (f >= FRACT_MAX) {
+		f -= FRACT_MAX;
+		m += 1;
+	}
+
+	timer0_fract = f;
+	timer0_millis = m;
+	timer0_overflow_count++;
+}
+
+unsigned long millis()
+{
+	unsigned long m;
+	uint8_t oldSREG = SREG;
+
+	// disable interrupts while we read timer0_millis or we might get an
+	// inconsistent value (e.g. in the middle of a write to timer0_millis)
+	cli();
+	m = timer0_millis;
+	SREG = oldSREG;
+
+	return m;
+}
+
+unsigned long micros() {
+	unsigned long m;
+	uint8_t oldSREG = SREG, t;
+	
+	cli();
+	m = timer0_overflow_count;
+#if defined(TCNT0)
+	t = TCNT0;
+#elif defined(TCNT0L)
+	t = TCNT0L;
+#else
+	#error TIMER 0 not defined
+#endif
+
+  
+#ifdef TIFR0
+	if ((TIFR0 & _BV(TOV0)) && (t < 255))
+		m++;
+#else
+	if ((TIFR & _BV(TOV0)) && (t < 255))
+		m++;
+#endif
+
+	SREG = oldSREG;
+	
+	return ((m << 8) + t) * (64 / clockCyclesPerMicrosecond());
+}
+
+void delay(unsigned long ms)
+{
+	uint16_t start = (uint16_t)micros();
+
+	while (ms > 0) {
+		if (((uint16_t)micros() - start) >= 1000) {
+			ms--;
+			start += 1000;
+		}
+	}
+}
+
+/* Delay for the given number of microseconds.  Assumes a 8 or 16 MHz clock. */
+void delayMicroseconds(unsigned int us)
+{
+	// calling avrlib's delay_us() function with low values (e.g. 1 or
+	// 2 microseconds) gives delays longer than desired.
+	//delay_us(us);
+#if F_CPU >= 20000000L
+	// for the 20 MHz clock on rare Arduino boards
+
+	// for a one-microsecond delay, simply wait 2 cycle and return. The overhead
+	// of the function call yields a delay of exactly a one microsecond.
+	__asm__ __volatile__ (
+		"nop" "\n\t"
+		"nop"); //just waiting 2 cycle
+	if (--us == 0)
+		return;
+
+	// the following loop takes a 1/5 of a microsecond (4 cycles)
+	// per iteration, so execute it five times for each microsecond of
+	// delay requested.
+	us = (us<<2) + us; // x5 us
+
+	// account for the time taken in the preceeding commands.
+	us -= 2;
+
+#elif F_CPU >= 16000000L
+	// for the 16 MHz clock on most Arduino boards
+
+	// for a one-microsecond delay, simply return.  the overhead
+	// of the function call yields a delay of approximately 1 1/8 us.
+	if (--us == 0)
+		return;
+
+	// the following loop takes a quarter of a microsecond (4 cycles)
+	// per iteration, so execute it four times for each microsecond of
+	// delay requested.
+	us <<= 2;
+
+	// account for the time taken in the preceeding commands.
+	us -= 2;
+#else
+	// for the 8 MHz internal clock on the ATmega168
+
+	// for a one- or two-microsecond delay, simply return.  the overhead of
+	// the function calls takes more than two microseconds.  can't just
+	// subtract two, since us is unsigned; we'd overflow.
+	if (--us == 0)
+		return;
+	if (--us == 0)
+		return;
+
+	// the following loop takes half of a microsecond (4 cycles)
+	// per iteration, so execute it twice for each microsecond of
+	// delay requested.
+	us <<= 1;
+    
+	// partially compensate for the time taken by the preceeding commands.
+	// we can't subtract any more than this or we'd overflow w/ small delays.
+	us--;
+#endif
+
+	// busy wait
+	__asm__ __volatile__ (
+		"1: sbiw %0,1" "\n\t" // 2 cycles
+		"brne 1b" : "=w" (us) : "0" (us) // 2 cycles
+	);
+}
+
+void init()
+{
+	// this needs to be called before setup() or some functions won't
+	// work there
+	sei();
+	
+	// on the ATmega168, timer 0 is also used for fast hardware pwm
+	// (using phase-correct PWM would mean that timer 0 overflowed half as often
+	// resulting in different millis() behavior on the ATmega8 and ATmega168)
+#if defined(TCCR0A) && defined(WGM01)
+	sbi(TCCR0A, WGM01);
+	sbi(TCCR0A, WGM00);
+#endif  
+
+	// set timer 0 prescale factor to 64
+#if defined(__AVR_ATmega128__)
+	// CPU specific: different values for the ATmega128
+	sbi(TCCR0, CS02);
+#elif defined(TCCR0) && defined(CS01) && defined(CS00)
+	// this combination is for the standard atmega8
+	sbi(TCCR0, CS01);
+	sbi(TCCR0, CS00);
+#elif defined(TCCR0B) && defined(CS01) && defined(CS00)
+	// this combination is for the standard 168/328/1280/2560
+	sbi(TCCR0B, CS01);
+	sbi(TCCR0B, CS00);
+#elif defined(TCCR0A) && defined(CS01) && defined(CS00)
+	// this combination is for the __AVR_ATmega645__ series
+	sbi(TCCR0A, CS01);
+	sbi(TCCR0A, CS00);
+#else
+	#error Timer 0 prescale factor 64 not set correctly
+#endif
+
+	// enable timer 0 overflow interrupt
+#if defined(TIMSK) && defined(TOIE0)
+	sbi(TIMSK, TOIE0);
+#elif defined(TIMSK0) && defined(TOIE0)
+	sbi(TIMSK0, TOIE0);
+#else
+	#error	Timer 0 overflow interrupt not set correctly
+#endif
+
+	// timers 1 and 2 are used for phase-correct hardware pwm
+	// this is better for motors as it ensures an even waveform
+	// note, however, that fast pwm mode can achieve a frequency of up
+	// 8 MHz (with a 16 MHz clock) at 50% duty cycle
+
+#if defined(TCCR1B) && defined(CS11) && defined(CS10)
+	TCCR1B = 0;
+
+	// set timer 1 prescale factor to 64
+	sbi(TCCR1B, CS11);
+#if F_CPU >= 8000000L
+	sbi(TCCR1B, CS10);
+#endif
+#elif defined(TCCR1) && defined(CS11) && defined(CS10)
+	sbi(TCCR1, CS11);
+#if F_CPU >= 8000000L
+	sbi(TCCR1, CS10);
+#endif
+#endif
+	// put timer 1 in 8-bit phase correct pwm mode
+#if defined(TCCR1A) && defined(WGM10)
+	sbi(TCCR1A, WGM10);
+#elif defined(TCCR1)
+	#warning this needs to be finished
+#endif
+
+	// set timer 2 prescale factor to 64
+#if defined(TCCR2) && defined(CS22)
+	sbi(TCCR2, CS22);
+#elif defined(TCCR2B) && defined(CS22)
+	sbi(TCCR2B, CS22);
+#else
+	#warning Timer 2 not finished (may not be present on this CPU)
+#endif
+
+	// configure timer 2 for phase correct pwm (8-bit)
+#if defined(TCCR2) && defined(WGM20)
+	sbi(TCCR2, WGM20);
+#elif defined(TCCR2A) && defined(WGM20)
+	sbi(TCCR2A, WGM20);
+#else
+	#warning Timer 2 not finished (may not be present on this CPU)
+#endif
+
+#if defined(TCCR3B) && defined(CS31) && defined(WGM30)
+	sbi(TCCR3B, CS31);		// set timer 3 prescale factor to 64
+	sbi(TCCR3B, CS30);
+	sbi(TCCR3A, WGM30);		// put timer 3 in 8-bit phase correct pwm mode
+#endif
+
+#if defined(TCCR4A) && defined(TCCR4B) && defined(TCCR4D) /* beginning of timer4 block for 32U4 and similar */
+	sbi(TCCR4B, CS42);		// set timer4 prescale factor to 64
+	sbi(TCCR4B, CS41);
+	sbi(TCCR4B, CS40);
+	sbi(TCCR4D, WGM40);		// put timer 4 in phase- and frequency-correct PWM mode	
+	sbi(TCCR4A, PWM4A);		// enable PWM mode for comparator OCR4A
+	sbi(TCCR4C, PWM4D);		// enable PWM mode for comparator OCR4D
+#else /* beginning of timer4 block for ATMEGA1280 and ATMEGA2560 */
+#if defined(TCCR4B) && defined(CS41) && defined(WGM40)
+	sbi(TCCR4B, CS41);		// set timer 4 prescale factor to 64
+	sbi(TCCR4B, CS40);
+	sbi(TCCR4A, WGM40);		// put timer 4 in 8-bit phase correct pwm mode
+#endif
+#endif /* end timer4 block for ATMEGA1280/2560 and similar */	
+
+#if defined(TCCR5B) && defined(CS51) && defined(WGM50)
+	sbi(TCCR5B, CS51);		// set timer 5 prescale factor to 64
+	sbi(TCCR5B, CS50);
+	sbi(TCCR5A, WGM50);		// put timer 5 in 8-bit phase correct pwm mode
+#endif
+
+#if defined(ADCSRA)
+	// set a2d prescale factor to 128
+	// 16 MHz / 128 = 125 KHz, inside the desired 50-200 KHz range.
+	// XXX: this will not work properly for other clock speeds, and
+	// this code should use F_CPU to determine the prescale factor.
+	sbi(ADCSRA, ADPS2);
+	sbi(ADCSRA, ADPS1);
+	sbi(ADCSRA, ADPS0);
+
+	// enable a2d conversions
+	sbi(ADCSRA, ADEN);
+#endif
+
+	// the bootloader connects pins 0 and 1 to the USART; disconnect them
+	// here so they can be used as normal digital i/o; they will be
+	// reconnected in Serial.begin()
+#if defined(UCSRB)
+	UCSRB = 0;
+#elif defined(UCSR0B)
+	UCSR0B = 0;
+#endif
+}
@@ -0,0 +1,178 @@
+/*
+  wiring_digital.c - digital input and output functions
+  Part of Arduino - http://www.arduino.cc/
+
+  Copyright (c) 2005-2006 David A. Mellis
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+
+  Modified 28 September 2010 by Mark Sproul
+
+  $Id: wiring.c 248 2007-02-03 15:36:30Z mellis $
+*/
+
+#define ARDUINO_MAIN
+#include "wiring_private.h"
+#include "pins_arduino.h"
+
+void pinMode(uint8_t pin, uint8_t mode)
+{
+	uint8_t bit = digitalPinToBitMask(pin);
+	uint8_t port = digitalPinToPort(pin);
+	volatile uint8_t *reg, *out;
+
+	if (port == NOT_A_PIN) return;
+
+	// JWS: can I let the optimizer do this?
+	reg = portModeRegister(port);
+	out = portOutputRegister(port);
+
+	if (mode == INPUT) { 
+		uint8_t oldSREG = SREG;
+                cli();
+		*reg &= ~bit;
+		*out &= ~bit;
+		SREG = oldSREG;
+	} else if (mode == INPUT_PULLUP) {
+		uint8_t oldSREG = SREG;
+                cli();
+		*reg &= ~bit;
+		*out |= bit;
+		SREG = oldSREG;
+	} else {
+		uint8_t oldSREG = SREG;
+                cli();
+		*reg |= bit;
+		SREG = oldSREG;
+	}
+}
+
+// Forcing this inline keeps the callers from having to push their own stuff
+// on the stack. It is a good performance win and only takes 1 more byte per
+// user than calling. (It will take more bytes on the 168.)
+//
+// But shouldn't this be moved into pinMode? Seems silly to check and do on
+// each digitalread or write.
+//
+// Mark Sproul:
+// - Removed inline. Save 170 bytes on atmega1280
+// - changed to a switch statment; added 32 bytes but much easier to read and maintain.
+// - Added more #ifdefs, now compiles for atmega645
+//
+//static inline void turnOffPWM(uint8_t timer) __attribute__ ((always_inline));
+//static inline void turnOffPWM(uint8_t timer)
+static void turnOffPWM(uint8_t timer)
+{
+	switch (timer)
+	{
+		#if defined(TCCR1A) && defined(COM1A1)
+		case TIMER1A:   cbi(TCCR1A, COM1A1);    break;
+		#endif
+		#if defined(TCCR1A) && defined(COM1B1)
+		case TIMER1B:   cbi(TCCR1A, COM1B1);    break;
+		#endif
+		
+		#if defined(TCCR2) && defined(COM21)
+		case  TIMER2:   cbi(TCCR2, COM21);      break;
+		#endif
+		
+		#if defined(TCCR0A) && defined(COM0A1)
+		case  TIMER0A:  cbi(TCCR0A, COM0A1);    break;
+		#endif
+		
+		#if defined(TIMER0B) && defined(COM0B1)
+		case  TIMER0B:  cbi(TCCR0A, COM0B1);    break;
+		#endif
+		#if defined(TCCR2A) && defined(COM2A1)
+		case  TIMER2A:  cbi(TCCR2A, COM2A1);    break;
+		#endif
+		#if defined(TCCR2A) && defined(COM2B1)
+		case  TIMER2B:  cbi(TCCR2A, COM2B1);    break;
+		#endif
+		
+		#if defined(TCCR3A) && defined(COM3A1)
+		case  TIMER3A:  cbi(TCCR3A, COM3A1);    break;
+		#endif
+		#if defined(TCCR3A) && defined(COM3B1)
+		case  TIMER3B:  cbi(TCCR3A, COM3B1);    break;
+		#endif
+		#if defined(TCCR3A) && defined(COM3C1)
+		case  TIMER3C:  cbi(TCCR3A, COM3C1);    break;
+		#endif
+
+		#if defined(TCCR4A) && defined(COM4A1)
+		case  TIMER4A:  cbi(TCCR4A, COM4A1);    break;
+		#endif					
+		#if defined(TCCR4A) && defined(COM4B1)
+		case  TIMER4B:  cbi(TCCR4A, COM4B1);    break;
+		#endif
+		#if defined(TCCR4A) && defined(COM4C1)
+		case  TIMER4C:  cbi(TCCR4A, COM4C1);    break;
+		#endif			
+		#if defined(TCCR4C) && defined(COM4D1)
+		case TIMER4D:	cbi(TCCR4C, COM4D1);	break;
+		#endif			
+			
+		#if defined(TCCR5A)
+		case  TIMER5A:  cbi(TCCR5A, COM5A1);    break;
+		case  TIMER5B:  cbi(TCCR5A, COM5B1);    break;
+		case  TIMER5C:  cbi(TCCR5A, COM5C1);    break;
+		#endif
+	}
+}
+
+void digitalWrite(uint8_t pin, uint8_t val)
+{
+	uint8_t timer = digitalPinToTimer(pin);
+	uint8_t bit = digitalPinToBitMask(pin);
+	uint8_t port = digitalPinToPort(pin);
+	volatile uint8_t *out;
+
+	if (port == NOT_A_PIN) return;
+
+	// If the pin that support PWM output, we need to turn it off
+	// before doing a digital write.
+	if (timer != NOT_ON_TIMER) turnOffPWM(timer);
+
+	out = portOutputRegister(port);
+
+	uint8_t oldSREG = SREG;
+	cli();
+
+	if (val == LOW) {
+		*out &= ~bit;
+	} else {
+		*out |= bit;
+	}
+
+	SREG = oldSREG;
+}
+
+int digitalRead(uint8_t pin)
+{
+	uint8_t timer = digitalPinToTimer(pin);
+	uint8_t bit = digitalPinToBitMask(pin);
+	uint8_t port = digitalPinToPort(pin);
+
+	if (port == NOT_A_PIN) return LOW;
+
+	// If the pin that support PWM output, we need to turn it off
+	// before getting a digital reading.
+	if (timer != NOT_ON_TIMER) turnOffPWM(timer);
+
+	if (*portInputRegister(port) & bit) return HIGH;
+	return LOW;
+}
@@ -0,0 +1,71 @@
+/*
+  wiring_private.h - Internal header file.
+  Part of Arduino - http://www.arduino.cc/
+
+  Copyright (c) 2005-2006 David A. Mellis
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+
+  $Id: wiring.h 239 2007-01-12 17:58:39Z mellis $
+*/
+
+#ifndef WiringPrivate_h
+#define WiringPrivate_h
+
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+#include "Arduino.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+#ifndef cbi
+#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
+#endif
+#ifndef sbi
+#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
+#endif
+
+#define EXTERNAL_INT_0 0
+#define EXTERNAL_INT_1 1
+#define EXTERNAL_INT_2 2
+#define EXTERNAL_INT_3 3
+#define EXTERNAL_INT_4 4
+#define EXTERNAL_INT_5 5
+#define EXTERNAL_INT_6 6
+#define EXTERNAL_INT_7 7
+
+#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
+#define EXTERNAL_NUM_INTERRUPTS 8
+#elif defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__) || defined(__AVR_ATmega644__) || defined(__AVR_ATmega644A__) || defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644PA__)
+#define EXTERNAL_NUM_INTERRUPTS 3
+#elif defined(__AVR_ATmega32U4__)
+#define EXTERNAL_NUM_INTERRUPTS 5
+#else
+#define EXTERNAL_NUM_INTERRUPTS 2
+#endif
+
+typedef void (*voidFuncPtr)(void);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif
@@ -0,0 +1,42 @@
+export CC = avr-g++
+
+export MCU = atmega328p
+export TARGET_ARCH = -mmcu=$(MCU)
+
+export CFLAGS =  -Wall -I./ -I/usr/share/arduino/hardware/arduino/variants/standard -I./PN532_SPI -I./PN532 -I/usr/share/arduino/hardware/arduino/cores/arduino -I/usr/share/arduino/libraries/SPI -I/usr/share/arduino/libraries -DF_CPU=16000000 -Os #-g
+export LDFLAGS = -g $(TARGET_ARCH) -lm -Wl,--gc-sections #	-Os
+
+TARGET = usb
+TERM = /dev/ttyACM0
+CPPFLAGS = -mmcu=$(MCU)
+PGMER = -c stk500v1 -b 57600 -P $(TERM)
+PGMERISP = -c stk500v1 -b 115200 -P $(TERM)
+ARVDUDECONF= -C /usr/local/arduino/arduino-0022/hardware/tools/avrdude.conf
+export DUDE = /usr/bin/avrdude -F -v -p $(MCU) $(AVRDUDECONF)
+
+C_SRC = main.c Arduino/wiring_digital.c
+CPP_SRC = PN532_SPI/PN532_SPI.cpp PN532/PN532.cpp PN532/SPI.cpp
+OBJS = $(C_SRC:.c=.o)
+OBJS += $(CPP_SRC:.cpp=.o)
+
+all: $(TARGET).hex
+
+clean:
+	rm -f *.o *.hex *.elf
+
+%.o:%.c
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $< -o $@
+%.o:%.cpp
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $< -o $@
+
+$(TARGET).elf: $(OBJS)
+	$(CC) $(LDFLAGS) -o $@ $(OBJS)
+
+$(TARGET).hex: $(TARGET).elf
+	avr-objcopy -j .text -j .data -O ihex $(TARGET).elf $(TARGET).hex
+	avr-objcopy -j .eeprom --set-section-flags=.eeprom="alloc,load" --change-section-lma .eeprom=0 -O ihex $(TARGET).elf eeprom.hex
+
+upload: $(TARGET).hex
+	stty -F $(TERM) hupcl # reset
+	$(DUDE) $(PGMERISP) -U flash:w:$(TARGET).hex
+
@@ -0,0 +1,886 @@
+/**************************************************************************/
+/*!
+    @file     PN532.cpp
+    @author   Adafruit Industries & Seeed Studio
+    @license  BSD
+*/
+/**************************************************************************/
+
+#include "Arduino.h"
+#include "PN532.h"
+#include "PN532_debug.h"
+#include <string.h>
+
+#define HAL(func)   (_interface->func)
+
+void send_serial(unsigned char);
+
+PN532::PN532(PN532Interface &interface)
+{
+    _interface = &interface;
+}
+
+/**************************************************************************/
+/*!
+    @brief  Setups the HW
+*/
+/**************************************************************************/
+void PN532::begin()
+{
+	send_serial('A');
+    HAL(begin)();
+	send_serial('B');
+    HAL(wakeup)();
+	send_serial('C');
+}
+
+/**************************************************************************/
+/*!
+    @brief  Prints a hexadecimal value in plain characters
+
+    @param  data      Pointer to the uint8_t data
+    @param  numBytes  Data length in bytes
+*/
+/**************************************************************************/
+void PN532::PrintHex(const uint8_t *data, const uint32_t numBytes)
+{
+#ifdef ARDUINO
+    for (uint8_t i = 0; i < numBytes; i++) {
+        if (data[i] < 0x10) {
+            Serial.print(" 0");
+        } else {
+            Serial.print(' ');
+        }
+        Serial.print(data[i], HEX);
+    }
+    Serial.println("");
+#else
+    for (uint8_t i = 0; i < numBytes; i++) {
+        printf(" %2X", data[i]);
+    }
+    printf("\n");
+#endif
+}
+
+/**************************************************************************/
+/*!
+    @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 data
+    @param  numBytes  Data length in bytes
+*/
+/**************************************************************************/
+void PN532::PrintHexChar(const uint8_t *data, const uint32_t numBytes)
+{
+#ifdef ARDUINO
+    for (uint8_t i = 0; i < numBytes; i++) {
+        if (data[i] < 0x10) {
+            Serial.print(" 0");
+        } else {
+            Serial.print(' ');
+        }
+        Serial.print(data[i], HEX);
+    }
+    Serial.print("    ");
+    for (uint8_t i = 0; i < numBytes; i++) {
+        char c = data[i];
+        if (c <= 0x1f || c > 0x7f) {
+            Serial.print('.');
+        } else {
+            Serial.print(c);
+        }
+    }
+    Serial.println("");
+#else
+    for (uint8_t i = 0; i < numBytes; i++) {
+        printf(" %2X", data[i]);
+    }
+    printf("    ");
+    for (uint8_t i = 0; i < numBytes; i++) {
+        char c = data[i];
+        if (c <= 0x1f || c > 0x7f) {
+            printf(".");
+        } else {
+            printf("%c", c);
+        }
+        printf("\n");
+    }
+#endif
+}
+
+/**************************************************************************/
+/*!
+    @brief  Checks the firmware version of the PN5xx chip
+
+    @returns  The chip's firmware version and ID
+*/
+/**************************************************************************/
+uint32_t PN532::getFirmwareVersion(void)
+{
+    uint32_t response;
+
+    pn532_packetbuffer[0] = PN532_COMMAND_GETFIRMWAREVERSION;
+
+    if (HAL(writeCommand)(pn532_packetbuffer, 1)) {
+        return 0;
+    }
+
+    // read data packet
+    int16_t status = HAL(readResponse)(pn532_packetbuffer, sizeof(pn532_packetbuffer));
+    if (0 > status) {
+        return 0;
+    }
+
+    response = pn532_packetbuffer[0];
+    response <<= 8;
+    response |= pn532_packetbuffer[1];
+    response <<= 8;
+    response |= pn532_packetbuffer[2];
+    response <<= 8;
+    response |= pn532_packetbuffer[3];
+
+    return response;
+}
+
+
+/**************************************************************************/
+/*!
+    Writes an 8-bit value that sets the state of the PN532's GPIO pins
+
+    @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
+
+    @returns 1 if everything executed properly, 0 for an error
+*/
+/**************************************************************************/
+bool PN532::writeGPIO(uint8_t pinstate)
+{
+    // 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 I2C)
+
+    DMSG("Writing P3 GPIO: ");
+    DMSG_HEX(pn532_packetbuffer[1]);
+    DMSG("\n");
+
+    // Send the WRITEGPIO command (0x0E)
+    if (HAL(writeCommand)(pn532_packetbuffer, 3))
+        return 0;
+
+    return (0 < HAL(readResponse)(pn532_packetbuffer, sizeof(pn532_packetbuffer)));
+}
+
+/**************************************************************************/
+/*!
+    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 PN532::readGPIO(void)
+{
+    pn532_packetbuffer[0] = PN532_COMMAND_READGPIO;
+
+    // Send the READGPIO command (0x0C)
+    if (HAL(writeCommand)(pn532_packetbuffer, 1))
+        return 0x0;
+
+    HAL(readResponse)(pn532_packetbuffer, sizeof(pn532_packetbuffer));
+
+    /* READGPIO response without prefix and suffix should be in the following format:
+
+      byte            Description
+      -------------   ------------------------------------------
+      b0              P3 GPIO Pins
+      b1              P7 GPIO Pins (not used ... taken by I2C)
+      b2              Interface Mode Pins (not used ... bus select pins)
+    */
+
+
+    DMSG("P3 GPIO: "); DMSG_HEX(pn532_packetbuffer[7]);
+    DMSG("P7 GPIO: "); DMSG_HEX(pn532_packetbuffer[8]);
+    DMSG("I0I1 GPIO: "); DMSG_HEX(pn532_packetbuffer[9]);
+    DMSG("\n");
+
+    return pn532_packetbuffer[0];
+}
+
+/**************************************************************************/
+/*!
+    @brief  Configures the SAM (Secure Access Module)
+*/
+/**************************************************************************/
+bool 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!
+
+    DMSG("SAMConfig\n");
+
+    if (HAL(writeCommand)(pn532_packetbuffer, 4))
+        return false;
+
+    return (0 < HAL(readResponse)(pn532_packetbuffer, sizeof(pn532_packetbuffer)));
+}
+
+/**************************************************************************/
+/*!
+    Sets the MxRtyPassiveActivation uint8_t 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 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;
+
+    if (HAL(writeCommand)(pn532_packetbuffer, 5))
+        return 0x0;  // no ACK
+
+    return (0 < HAL(readResponse)(pn532_packetbuffer, sizeof(pn532_packetbuffer)));
+}
+
+/***** ISO14443A Commands ******/
+
+/**************************************************************************/
+/*!
+    Waits for an ISO14443A target to enter the field
+
+    @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       The number of tries before timing out
+    @param  inlist        If set to true, the card will be inlisted
+
+    @returns 1 if everything executed properly, 0 for an error
+*/
+/**************************************************************************/
+bool PN532::readPassiveTargetID(uint8_t cardbaudrate, uint8_t *uid, uint8_t *uidLength, uint16_t timeout, bool inlist)
+{
+    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 (HAL(writeCommand)(pn532_packetbuffer, 3)) {
+        return 0x0;  // command failed
+    }
+
+    // read data packet
+    if (HAL(readResponse)(pn532_packetbuffer, sizeof(pn532_packetbuffer), timeout) < 0) {
+        return 0x0;
+    }
+
+    // check some basic stuff
+    /* ISO14443A card response should be in the following format:
+
+      byte            Description
+      -------------   ------------------------------------------
+      b0              Tags Found
+      b1              Tag Number (only one used in this example)
+      b2..3           SENS_RES
+      b4              SEL_RES
+      b5              NFCID Length
+      b6..NFCIDLen    NFCID
+    */
+
+    if (pn532_packetbuffer[0] != 1)
+        return 0;
+
+    uint16_t sens_res = pn532_packetbuffer[2];
+    sens_res <<= 8;
+    sens_res |= pn532_packetbuffer[3];
+
+    DMSG("ATQA: 0x");  DMSG_HEX(sens_res);
+    DMSG("SAK: 0x");  DMSG_HEX(pn532_packetbuffer[4]);
+    DMSG("\n");
+
+    /* Card appears to be Mifare Classic */
+    *uidLength = pn532_packetbuffer[5];
+
+    for (uint8_t i = 0; i < pn532_packetbuffer[5]; i++) {
+        uid[i] = pn532_packetbuffer[6 + i];
+    }
+
+    if (inlist) {
+        inListedTag = pn532_packetbuffer[1];
+    }
+
+    return 1;
+}
+
+
+/***** Mifare Classic Functions ******/
+
+/**************************************************************************/
+/*!
+      Indicates whether the specified block number is the first block
+      in the sector (block 0 relative to the current sector)
+*/
+/**************************************************************************/
+bool 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);
+}
+
+/**************************************************************************/
+/*!
+      Indicates whether the specified block number is the sector trailer
+*/
+/**************************************************************************/
+bool 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 bytes
+                          key value
+
+    @returns 1 if everything executed properly, 0 for an error
+*/
+/**************************************************************************/
+uint8_t PN532::mifareclassic_AuthenticateBlock (uint8_t *uid, uint8_t uidLen, uint32_t blockNumber, uint8_t keyNumber, uint8_t *keyData)
+{
+    uint8_t i;
+
+    // Hang on to the key and uid data
+    memcpy (_key, keyData, 6);
+    memcpy (_uid, uid, uidLen);
+    _uidLen = uidLen;
+
+    // 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 bytes card ID */
+    }
+
+    if (HAL(writeCommand)(pn532_packetbuffer, 10 + _uidLen))
+        return 0;
+
+    // Read the response packet
+    HAL(readResponse)(pn532_packetbuffer, sizeof(pn532_packetbuffer));
+
+    // 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[0] != 0x00) {
+        DMSG("Authentification failed\n");
+        return 0;
+    }
+
+    return 1;
+}
+
+/**************************************************************************/
+/*!
+    Tries to read an entire 16-bytes 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 PN532::mifareclassic_ReadDataBlock (uint8_t blockNumber, uint8_t *data)
+{
+    DMSG("Trying to read 16 bytes from block ");
+    DMSG_INT(blockNumber);
+
+    /* 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 (HAL(writeCommand)(pn532_packetbuffer, 4)) {
+        return 0;
+    }
+
+    /* Read the response packet */
+    HAL(readResponse)(pn532_packetbuffer, sizeof(pn532_packetbuffer));
+
+    /* If byte 8 isn't 0x00 we probably have an error */
+    if (pn532_packetbuffer[0] != 0x00) {
+        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 + 1, 16);
+
+    return 1;
+}
+
+/**************************************************************************/
+/*!
+    Tries to write an entire 16-bytes 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 PN532::mifareclassic_WriteDataBlock (uint8_t blockNumber, uint8_t *data)
+{
+    /* 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 (HAL(writeCommand)(pn532_packetbuffer, 20)) {
+        return 0;
+    }
+
+    /* Read the response packet */
+    return (0 < HAL(readResponse)(pn532_packetbuffer, sizeof(pn532_packetbuffer)));
+}
+
+/**************************************************************************/
+/*!
+    Formats a Mifare Classic card to store NDEF Records
+
+    @returns 1 if everything executed properly, 0 for an error
+*/
+/**************************************************************************/
+uint8_t 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 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, len + 5, 0xD1, 0x01, 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 ******/
+
+/**************************************************************************/
+/*!
+    Tries to read an entire 4-bytes 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)
+*/
+/**************************************************************************/
+uint8_t PN532::mifareultralight_ReadPage (uint8_t page, uint8_t *buffer)
+{
+    if (page >= 64) {
+        DMSG("Page value out of range\n");
+        return 0;
+    }
+
+    /* 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 (HAL(writeCommand)(pn532_packetbuffer, 4)) {
+        return 0;
+    }
+
+    /* Read the response packet */
+    HAL(readResponse)(pn532_packetbuffer, sizeof(pn532_packetbuffer));
+
+    /* If byte 8 isn't 0x00 we probably have an error */
+    if (pn532_packetbuffer[0] == 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 bytes or 4  */
+        /* pages at a time ... we simply discard the last 12  */
+        /* bytes                                              */
+        memcpy (buffer, pn532_packetbuffer + 1, 4);
+    } else {
+        return 0;
+    }
+
+    // Return OK signal
+    return 1;
+}
+
+/**************************************************************************/
+/*!
+    Tries to write an entire 4-bytes data buffer at the specified page
+    address.
+
+    @param  page     The page number to write into.  (0..63).
+    @param  buffer   The byte array that contains the data to write.
+
+    @returns 1 if everything executed properly, 0 for an error
+*/
+/**************************************************************************/
+uint8_t PN532::mifareultralight_WritePage (uint8_t page, uint8_t *buffer)
+{
+    /* Prepare the first command */
+    pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE;
+    pn532_packetbuffer[1] = 1;                           /* Card number */
+    pn532_packetbuffer[2] = MIFARE_CMD_WRITE_ULTRALIGHT; /* Mifare UL Write cmd = 0xA2 */
+    pn532_packetbuffer[3] = page;                        /* page Number (0..63) */
+    memcpy (pn532_packetbuffer + 4, buffer, 4);          /* Data Payload */
+
+    /* Send the command */
+    if (HAL(writeCommand)(pn532_packetbuffer, 8)) {
+        return 0;
+    }
+
+    /* Read the response packet */
+    return (0 < HAL(readResponse)(pn532_packetbuffer, sizeof(pn532_packetbuffer)));
+}
+
+/**************************************************************************/
+/*!
+    @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
+*/
+/**************************************************************************/
+bool PN532::inDataExchange(uint8_t *send, uint8_t sendLength, uint8_t *response, uint8_t *responseLength)
+{
+    uint8_t i;
+
+    pn532_packetbuffer[0] = 0x40; // PN532_COMMAND_INDATAEXCHANGE;
+    pn532_packetbuffer[1] = inListedTag;
+
+    if (HAL(writeCommand)(pn532_packetbuffer, 2, send, sendLength)) {
+        return false;
+    }
+
+    int16_t status = HAL(readResponse)(response, *responseLength, 1000);
+    if (status < 0) {
+        return false;
+    }
+
+    if ((response[0] & 0x3f) != 0) {
+        DMSG("Status code indicates an error\n");
+        return false;
+    }
+
+    uint8_t length = status;
+    length -= 1;
+
+    if (length > *responseLength) {
+        length = *responseLength; // silent truncation...
+    }
+
+    for (uint8_t i = 0; i < length; i++) {
+        response[i] = response[i + 1];
+    }
+    *responseLength = length;
+
+    return true;
+}
+
+/**************************************************************************/
+/*!
+    @brief  'InLists' a passive target. PN532 acting as reader/initiator,
+            peer acting as card/responder.
+*/
+/**************************************************************************/
+bool PN532::inListPassiveTarget()
+{
+    pn532_packetbuffer[0] = PN532_COMMAND_INLISTPASSIVETARGET;
+    pn532_packetbuffer[1] = 1;
+    pn532_packetbuffer[2] = 0;
+
+    DMSG("inList passive target\n");
+
+    if (HAL(writeCommand)(pn532_packetbuffer, 3)) {
+        return false;
+    }
+
+    int16_t status = HAL(readResponse)(pn532_packetbuffer, sizeof(pn532_packetbuffer), 30000);
+    if (status < 0) {
+        return false;
+    }
+
+    if (pn532_packetbuffer[0] != 1) {
+        return false;
+    }
+
+    inListedTag = pn532_packetbuffer[1];
+
+    return true;
+}
+
+int8_t PN532::tgInitAsTarget(const uint8_t* command, const uint8_t len, const uint16_t timeout){
+  
+  int8_t status = HAL(writeCommand)(command, len);
+    if (status < 0) {
+        return -1;
+    }
+
+    status = HAL(readResponse)(pn532_packetbuffer, sizeof(pn532_packetbuffer), timeout);
+    if (status > 0) {
+        return 1;
+    } else if (PN532_TIMEOUT == status) {
+        return 0;
+    } else {
+        return -2;
+    }
+}
+
+/**
+ * Peer to Peer
+ */
+int8_t PN532::tgInitAsTarget(uint16_t timeout)
+{
+    const uint8_t command[] = {
+        PN532_COMMAND_TGINITASTARGET,
+        0,
+        0x00, 0x00,         //SENS_RES
+        0x00, 0x00, 0x00,   //NFCID1
+        0x40,               //SEL_RES
+
+        0x01, 0xFE, 0x0F, 0xBB, 0xBA, 0xA6, 0xC9, 0x89, // POL_RES
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0xFF, 0xFF,
+
+        0x01, 0xFE, 0x0F, 0xBB, 0xBA, 0xA6, 0xC9, 0x89, 0x00, 0x00, //NFCID3t: Change this to desired value
+
+        0x06, 0x46,  0x66, 0x6D, 0x01, 0x01, 0x10, 0x00// LLCP magic number and version parameter
+    };
+    return tgInitAsTarget(command, sizeof(command), timeout);
+}
+
+int16_t PN532::tgGetData(uint8_t *buf, uint8_t len)
+{
+    buf[0] = PN532_COMMAND_TGGETDATA;
+
+    if (HAL(writeCommand)(buf, 1)) {
+        return -1;
+    }
+
+    int16_t status = HAL(readResponse)(buf, len, 3000);
+    if (0 >= status) {
+        return status;
+    }
+
+    uint16_t length = status - 1;
+
+
+    if (buf[0] != 0) {
+        DMSG("status is not ok\n");
+        return -5;
+    }
+
+    for (uint8_t i = 0; i < length; i++) {
+        buf[i] = buf[i + 1];
+    }
+
+    return length;
+}
+
+bool PN532::tgSetData(const uint8_t *header, uint8_t hlen, const uint8_t *body, uint8_t blen)
+{
+    if (hlen > (sizeof(pn532_packetbuffer) - 1)) {
+        if ((body != 0) || (header == pn532_packetbuffer)) {
+            DMSG("tgSetData:buffer too small\n");
+            return false;
+        }
+
+        pn532_packetbuffer[0] = PN532_COMMAND_TGSETDATA;
+        if (HAL(writeCommand)(pn532_packetbuffer, 1, header, hlen)) {
+            return false;
+        }
+    } else {
+        for (int8_t i = hlen - 1; i >= 0; i--){
+            pn532_packetbuffer[i + 1] = header[i];
+        }
+        pn532_packetbuffer[0] = PN532_COMMAND_TGSETDATA;
+
+        if (HAL(writeCommand)(pn532_packetbuffer, hlen + 1, body, blen)) {
+            return false;
+        }
+    }
+
+    if (0 > HAL(readResponse)(pn532_packetbuffer, sizeof(pn532_packetbuffer), 3000)) {
+        return false;
+    }
+
+    if (0 != pn532_packetbuffer[0]) {
+        return false;
+    }
+
+    return true;
+}
+
+int16_t PN532::inRelease(const uint8_t relevantTarget){
+
+    pn532_packetbuffer[0] = PN532_COMMAND_INRELEASE;
+    pn532_packetbuffer[1] = relevantTarget;
+
+    if (HAL(writeCommand)(pn532_packetbuffer, 2)) {
+        return 0;
+    }
+
+    // read data packet
+    return HAL(readResponse)(pn532_packetbuffer, sizeof(pn532_packetbuffer));
+}
+
+
@@ -0,0 +1,179 @@
+/**************************************************************************/
+/*!
+    @file     PN532.h
+    @author   Adafruit Industries & Seeed Studio
+    @license  BSD
+*/
+/**************************************************************************/
+
+#ifndef __PN532_H__
+#define __PN532_H__
+
+#include <stdint.h>
+#include "PN532Interface.h"
+
+// PN532 Commands
+#define PN532_COMMAND_DIAGNOSE              (0x00)
+#define PN532_COMMAND_GETFIRMWAREVERSION    (0x02)
+#define PN532_COMMAND_GETGENERALSTATUS      (0x04)
+#define PN532_COMMAND_READREGISTER          (0x06)
+#define PN532_COMMAND_WRITEREGISTER         (0x08)
+#define PN532_COMMAND_READGPIO              (0x0C)
+#define PN532_COMMAND_WRITEGPIO             (0x0E)
+#define PN532_COMMAND_SETSERIALBAUDRATE     (0x10)
+#define PN532_COMMAND_SETPARAMETERS         (0x12)
+#define PN532_COMMAND_SAMCONFIGURATION      (0x14)
+#define PN532_COMMAND_POWERDOWN             (0x16)
+#define PN532_COMMAND_RFCONFIGURATION       (0x32)
+#define PN532_COMMAND_RFREGULATIONTEST      (0x58)
+#define PN532_COMMAND_INJUMPFORDEP          (0x56)
+#define PN532_COMMAND_INJUMPFORPSL          (0x46)
+#define PN532_COMMAND_INLISTPASSIVETARGET   (0x4A)
+#define PN532_COMMAND_INATR                 (0x50)
+#define PN532_COMMAND_INPSL                 (0x4E)
+#define PN532_COMMAND_INDATAEXCHANGE        (0x40)
+#define PN532_COMMAND_INCOMMUNICATETHRU     (0x42)
+#define PN532_COMMAND_INDESELECT            (0x44)
+#define PN532_COMMAND_INRELEASE             (0x52)
+#define PN532_COMMAND_INSELECT              (0x54)
+#define PN532_COMMAND_INAUTOPOLL            (0x60)
+#define PN532_COMMAND_TGINITASTARGET        (0x8C)
+#define PN532_COMMAND_TGSETGENERALBYTES     (0x92)
+#define PN532_COMMAND_TGGETDATA             (0x86)
+#define PN532_COMMAND_TGSETDATA             (0x8E)
+#define PN532_COMMAND_TGSETMETADATA         (0x94)
+#define PN532_COMMAND_TGGETINITIATORCOMMAND (0x88)
+#define PN532_COMMAND_TGRESPONSETOINITIATOR (0x90)
+#define PN532_COMMAND_TGGETTARGETSTATUS     (0x8A)
+
+#define PN532_RESPONSE_INDATAEXCHANGE       (0x41)
+#define PN532_RESPONSE_INLISTPASSIVETARGET  (0x4B)
+
+
+#define PN532_MIFARE_ISO14443A              (0x00)
+
+// Mifare Commands
+#define MIFARE_CMD_AUTH_A                   (0x60)
+#define MIFARE_CMD_AUTH_B                   (0x61)
+#define MIFARE_CMD_READ                     (0x30)
+#define MIFARE_CMD_WRITE                    (0xA0)
+#define MIFARE_CMD_WRITE_ULTRALIGHT         (0xA2)
+#define MIFARE_CMD_TRANSFER                 (0xB0)
+#define MIFARE_CMD_DECREMENT                (0xC0)
+#define MIFARE_CMD_INCREMENT                (0xC1)
+#define MIFARE_CMD_STORE                    (0xC2)
+
+// Prefixes for NDEF Records (to identify record type)
+#define NDEF_URIPREFIX_NONE                 (0x00)
+#define NDEF_URIPREFIX_HTTP_WWWDOT          (0x01)
+#define NDEF_URIPREFIX_HTTPS_WWWDOT         (0x02)
+#define NDEF_URIPREFIX_HTTP                 (0x03)
+#define NDEF_URIPREFIX_HTTPS                (0x04)
+#define NDEF_URIPREFIX_TEL                  (0x05)
+#define NDEF_URIPREFIX_MAILTO               (0x06)
+#define NDEF_URIPREFIX_FTP_ANONAT           (0x07)
+#define NDEF_URIPREFIX_FTP_FTPDOT           (0x08)
+#define NDEF_URIPREFIX_FTPS                 (0x09)
+#define NDEF_URIPREFIX_SFTP                 (0x0A)
+#define NDEF_URIPREFIX_SMB                  (0x0B)
+#define NDEF_URIPREFIX_NFS                  (0x0C)
+#define NDEF_URIPREFIX_FTP                  (0x0D)
+#define NDEF_URIPREFIX_DAV                  (0x0E)
+#define NDEF_URIPREFIX_NEWS                 (0x0F)
+#define NDEF_URIPREFIX_TELNET               (0x10)
+#define NDEF_URIPREFIX_IMAP                 (0x11)
+#define NDEF_URIPREFIX_RTSP                 (0x12)
+#define NDEF_URIPREFIX_URN                  (0x13)
+#define NDEF_URIPREFIX_POP                  (0x14)
+#define NDEF_URIPREFIX_SIP                  (0x15)
+#define NDEF_URIPREFIX_SIPS                 (0x16)
+#define NDEF_URIPREFIX_TFTP                 (0x17)
+#define NDEF_URIPREFIX_BTSPP                (0x18)
+#define NDEF_URIPREFIX_BTL2CAP              (0x19)
+#define NDEF_URIPREFIX_BTGOEP               (0x1A)
+#define NDEF_URIPREFIX_TCPOBEX              (0x1B)
+#define NDEF_URIPREFIX_IRDAOBEX             (0x1C)
+#define NDEF_URIPREFIX_FILE                 (0x1D)
+#define NDEF_URIPREFIX_URN_EPC_ID           (0x1E)
+#define NDEF_URIPREFIX_URN_EPC_TAG          (0x1F)
+#define NDEF_URIPREFIX_URN_EPC_PAT          (0x20)
+#define NDEF_URIPREFIX_URN_EPC_RAW          (0x21)
+#define NDEF_URIPREFIX_URN_EPC              (0x22)
+#define NDEF_URIPREFIX_URN_NFC              (0x23)
+
+#define PN532_GPIO_VALIDATIONBIT            (0x80)
+#define PN532_GPIO_P30                      (0)
+#define PN532_GPIO_P31                      (1)
+#define PN532_GPIO_P32                      (2)
+#define PN532_GPIO_P33                      (3)
+#define PN532_GPIO_P34                      (4)
+#define PN532_GPIO_P35                      (5)
+
+class PN532
+{
+public:
+    PN532(PN532Interface &interface);
+
+    void begin(void);
+
+    // Generic PN532 functions
+    bool SAMConfig(void);
+    uint32_t getFirmwareVersion(void);
+    bool writeGPIO(uint8_t pinstate);
+    uint8_t readGPIO(void);
+    bool setPassiveActivationRetries(uint8_t maxRetries);
+
+    /**
+    * @brief    Init PN532 as a target
+    * @param    timeout max time to wait, 0 means no timeout
+    * @return   > 0     success
+    *           = 0     timeout
+    *           < 0     failed
+    */
+    int8_t tgInitAsTarget(uint16_t timeout = 0);
+    int8_t tgInitAsTarget(const uint8_t* command, const uint8_t len, const uint16_t timeout = 0);
+
+    int16_t tgGetData(uint8_t *buf, uint8_t len);
+    bool tgSetData(const uint8_t *header, uint8_t hlen, const uint8_t *body = 0, uint8_t blen = 0);
+
+    int16_t inRelease(const uint8_t relevantTarget = 0);
+
+    // ISO14443A functions
+    bool inListPassiveTarget();
+    bool readPassiveTargetID(uint8_t cardbaudrate, uint8_t *uid, uint8_t *uidLength, uint16_t timeout = 1000, bool inlist = false);
+    bool inDataExchange(uint8_t *send, uint8_t sendLength, uint8_t *response, uint8_t *responseLength);
+
+    // 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);
+    uint8_t mifareclassic_FormatNDEF (void);
+    uint8_t mifareclassic_WriteNDEFURI (uint8_t sectorNumber, uint8_t uriIdentifier, const char *url);
+
+    // Mifare Ultralight functions
+    uint8_t mifareultralight_ReadPage (uint8_t page, uint8_t *buffer);
+    uint8_t mifareultralight_WritePage (uint8_t page, uint8_t *buffer);
+
+    // Help functions to display formatted text
+    static void PrintHex(const uint8_t *data, const uint32_t numBytes);
+    static void PrintHexChar(const uint8_t *pbtData, const uint32_t numBytes);
+
+    uint8_t *getBuffer(uint8_t *len) {
+        *len = sizeof(pn532_packetbuffer) - 4;
+        return pn532_packetbuffer;
+    };
+
+private:
+    uint8_t _uid[7];  // ISO14443A uid
+    uint8_t _uidLen;  // uid len
+    uint8_t _key[6];  // Mifare Classic key
+    uint8_t inListedTag; // Tg number of inlisted tag.
+
+    uint8_t pn532_packetbuffer[64];
+
+    PN532Interface *_interface;
+};
+
+#endif
@@ -0,0 +1,56 @@
+
+
+#ifndef __PN532_INTERFACE_H__
+#define __PN532_INTERFACE_H__
+
+#include <stdint.h>
+
+#define PN532_PREAMBLE                (0x00)
+#define PN532_STARTCODE1              (0x00)
+#define PN532_STARTCODE2              (0xFF)
+#define PN532_POSTAMBLE               (0x00)
+
+#define PN532_HOSTTOPN532             (0xD4)
+#define PN532_PN532TOHOST             (0xD5)
+
+#define PN532_ACK_WAIT_TIME           (10)  // ms, timeout of waiting for ACK
+
+#define PN532_INVALID_ACK             (-1)
+#define PN532_TIMEOUT                 (-2)
+#define PN532_INVALID_FRAME           (-3)
+#define PN532_NO_SPACE                (-4)
+
+#define REVERSE_BITS_ORDER(b)         b = (b & 0xF0) >> 4 | (b & 0x0F) << 4; \
+                                      b = (b & 0xCC) >> 2 | (b & 0x33) << 2; \
+                                      b = (b & 0xAA) >> 1 | (b & 0x55) << 1
+
+class PN532Interface
+{
+public:
+    virtual void begin() = 0;
+    virtual void wakeup() = 0;
+
+    /**
+    * @brief    write a command and check ack
+    * @param    header  packet header
+    * @param    hlen    length of header
+    * @param    body    packet body
+    * @param    blen    length of body
+    * @return   0       success
+    *           not 0   failed
+    */
+    virtual int8_t writeCommand(const uint8_t *header, uint8_t hlen, const uint8_t *body = 0, uint8_t blen = 0) = 0;
+
+    /**
+    * @brief    read the response of a command, strip prefix and suffix
+    * @param    buf     to contain the response data
+    * @param    len     lenght to read
+    * @param    timeout max time to wait, 0 means no timeout
+    * @return   >=0     length of response without prefix and suffix
+    *           <0      failed to read response
+    */
+    virtual int16_t readResponse(uint8_t buf[], uint8_t len, uint16_t timeout = 1000) = 0;
+};
+
+#endif
+
@@ -0,0 +1,20 @@
+#ifndef __DEBUG_H__
+#define __DEBUG_H__
+
+//#define DEBUG
+
+#include "Arduino.h"
+
+#ifdef DEBUG
+#define DMSG(args...)       Serial.print(args)
+#define DMSG_STR(str)       Serial.println(str)
+#define DMSG_HEX(num)       Serial.print(' '); Serial.print(num, HEX)
+#define DMSG_INT(num)       Serial.print(' '); Serial.print(num)
+#else
+#define DMSG(args...)
+#define DMSG_STR(str)
+#define DMSG_HEX(num)
+#define DMSG_INT(num)
+#endif
+
+#endif
@@ -0,0 +1,30 @@
+## NFC library for Arduino
+
+This is an Arduino library for PN532 to use NFC technology.
+It works with
+
++ [NFC Shield](http://goo.gl/Cac2OH)
++ [Xadow NFC](http://goo.gl/qBZMt0)
++ [PN532 NFC/RFID controller breakout board](http://goo.gl/tby9Sw)
+
+### Features
++ Support I2C, SPI and HSU of PN532
++ Read/write Mifare Classic Card
++ Works with [Don's NDEF Library](http://goo.gl/jDjsXl)
++ Support Peer to Peer communication(exchange data with android 4.0+)
++ Support [mbed platform](http://goo.gl/kGPovZ)
+
+### Getting Started
+1. Download [zip file](http://goo.gl/F6beRM) and 
+extract the 4 folders(PN532, PN532_SPI, PN532_I2C and PN532_HSU) into Arduino's libraries.
+2. Downlaod [Don's NDEF library](http://goo.gl/ewxeAe) and extract it intro Arduino's libraries.
+3. Follow the examples of the two libraries.
+
+### To do
++ Card emulation
+
+### Contribution
+It's based on [Adafruit_NFCShield_I2C](http://goo.gl/pk3FdB). 
+[Seeed Studio](http://goo.gl/zh1iQh) adds SPI interface and peer to peer communication support. 
+@Don writes the [NDEF library](http://goo.gl/jDjsXl) to make it more easy to use. 
+@JiapengLi adds HSU interface.
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2010 by Cristian Maglie <c.maglie@bug.st>
+ * SPI Master library for arduino.
+ *
+ * This file is free software; you can redistribute it and/or modify
+ * it under the terms of either the GNU General Public License version 2
+ * or the GNU Lesser General Public License version 2.1, both as
+ * published by the Free Software Foundation.
+ */
+
+#include "pins_arduino.h"
+#include "SPI.h"
+
+SPIClass SPI;
+
+void SPIClass::begin() {
+
+  // Set SS to high so a connected chip will be "deselected" by default
+  digitalWrite(SS, HIGH);
+
+  // When the SS pin is set as OUTPUT, it can be used as
+  // a general purpose output port (it doesn't influence
+  // SPI operations).
+  pinMode(SS, OUTPUT);
+
+  // Warning: if the SS pin ever becomes a LOW INPUT then SPI
+  // automatically switches to Slave, so the data direction of
+  // the SS pin MUST be kept as OUTPUT.
+  SPCR |= _BV(MSTR);
+  SPCR |= _BV(SPE);
+
+  // Set direction register for SCK and MOSI pin.
+  // MISO pin automatically overrides to INPUT.
+  // By doing this AFTER enabling SPI, we avoid accidentally
+  // clocking in a single bit since the lines go directly
+  // from "input" to SPI control.  
+  // http://code.google.com/p/arduino/issues/detail?id=888
+  pinMode(SCK, OUTPUT);
+  pinMode(MOSI, OUTPUT);
+}
+
+
+void SPIClass::end() {
+  SPCR &= ~_BV(SPE);
+}
+
+void SPIClass::setBitOrder(uint8_t bitOrder)
+{
+  if(bitOrder == LSBFIRST) {
+    SPCR |= _BV(DORD);
+  } else {
+    SPCR &= ~(_BV(DORD));
+  }
+}
+
+void SPIClass::setDataMode(uint8_t mode)
+{
+  SPCR = (SPCR & ~SPI_MODE_MASK) | mode;
+}
+
+void SPIClass::setClockDivider(uint8_t rate)
+{
+  SPCR = (SPCR & ~SPI_CLOCK_MASK) | (rate & SPI_CLOCK_MASK);
+  SPSR = (SPSR & ~SPI_2XCLOCK_MASK) | ((rate >> 2) & SPI_2XCLOCK_MASK);
+}
+
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2010 by Cristian Maglie <c.maglie@bug.st>
+ * SPI Master library for arduino.
+ *
+ * This file is free software; you can redistribute it and/or modify
+ * it under the terms of either the GNU General Public License version 2
+ * or the GNU Lesser General Public License version 2.1, both as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef _SPI_H_INCLUDED
+#define _SPI_H_INCLUDED
+
+#include <stdio.h>
+#include <Arduino.h>
+#include <avr/pgmspace.h>
+
+#define SPI_CLOCK_DIV4 0x00
+#define SPI_CLOCK_DIV16 0x01
+#define SPI_CLOCK_DIV64 0x02
+#define SPI_CLOCK_DIV128 0x03
+#define SPI_CLOCK_DIV2 0x04
+#define SPI_CLOCK_DIV8 0x05
+#define SPI_CLOCK_DIV32 0x06
+//#define SPI_CLOCK_DIV64 0x07
+
+#define SPI_MODE0 0x00
+#define SPI_MODE1 0x04
+#define SPI_MODE2 0x08
+#define SPI_MODE3 0x0C
+
+#define SPI_MODE_MASK 0x0C  // CPOL = bit 3, CPHA = bit 2 on SPCR
+#define SPI_CLOCK_MASK 0x03  // SPR1 = bit 1, SPR0 = bit 0 on SPCR
+#define SPI_2XCLOCK_MASK 0x01  // SPI2X = bit 0 on SPSR
+
+class SPIClass {
+public:
+  inline static byte transfer(byte _data);
+
+  // SPI Configuration methods
+
+  inline static void attachInterrupt();
+  inline static void detachInterrupt(); // Default
+
+  static void begin(); // Default
+  static void end();
+
+  static void setBitOrder(uint8_t);
+  static void setDataMode(uint8_t);
+  static void setClockDivider(uint8_t);
+};
+
+extern SPIClass SPI;
+
+byte SPIClass::transfer(byte _data) {
+  SPDR = _data;
+  while (!(SPSR & _BV(SPIF)))
+    ;
+  return SPDR;
+}
+
+void SPIClass::attachInterrupt() {
+  SPCR |= _BV(SPIE);
+}
+
+void SPIClass::detachInterrupt() {
+  SPCR &= ~_BV(SPIE);
+}
+
+#endif
@@ -0,0 +1,255 @@
+/**************************************************************************/
+/*!
+    @file     emulatetag.cpp
+    @author   Armin Wieser
+    @license  BSD
+*/
+/**************************************************************************/
+
+#include "emulatetag.h"
+#include "PN532_debug.h"
+
+#include <string.h>
+
+#define MAX_TGREAD
+
+
+// Command APDU
+#define C_APDU_CLA   0
+#define C_APDU_INS   1 // instruction
+#define C_APDU_P1    2 // parameter 1
+#define C_APDU_P2    3 // parameter 2
+#define C_APDU_LC    4 // length command
+#define C_APDU_DATA  5 // data
+
+#define C_APDU_P1_SELECT_BY_ID   0x00
+#define C_APDU_P1_SELECT_BY_NAME 0x04
+
+// Response APDU
+#define R_APDU_SW1_COMMAND_COMPLETE 0x90 
+#define R_APDU_SW2_COMMAND_COMPLETE 0x00 
+
+#define R_APDU_SW1_NDEF_TAG_NOT_FOUND 0x6a
+#define R_APDU_SW2_NDEF_TAG_NOT_FOUND 0x82
+
+#define R_APDU_SW1_FUNCTION_NOT_SUPPORTED 0x6A
+#define R_APDU_SW2_FUNCTION_NOT_SUPPORTED 0x81
+
+#define R_APDU_SW1_MEMORY_FAILURE 0x65
+#define R_APDU_SW2_MEMORY_FAILURE 0x81
+
+#define R_APDU_SW1_END_OF_FILE_BEFORE_REACHED_LE_BYTES 0x62
+#define R_APDU_SW2_END_OF_FILE_BEFORE_REACHED_LE_BYTES 0x82
+
+// ISO7816-4 commands
+#define ISO7816_SELECT_FILE 0xA4
+#define ISO7816_READ_BINARY 0xB0
+#define ISO7816_UPDATE_BINARY 0xD6
+
+typedef enum { NONE, CC, NDEF } tag_file;   // CC ... Compatibility Container
+
+bool EmulateTag::init(){
+  pn532.begin();
+  return pn532.SAMConfig();
+}
+
+void EmulateTag::setNdefFile(const uint8_t* ndef, const int16_t ndefLength){
+  if(ndefLength >  (NDEF_MAX_LENGTH -2)){
+	DMSG("ndef file too large (> NDEF_MAX_LENGHT -2) - aborting");
+	return;
+  }
+
+  ndef_file[0] = ndefLength >> 8;
+  ndef_file[1] = ndefLength & 0xFF;
+  memcpy(ndef_file+2, ndef, ndefLength);
+}
+
+void EmulateTag::setUid(uint8_t* uid){
+  uidPtr = uid;
+}
+
+bool EmulateTag::emulate(const uint16_t tgInitAsTargetTimeout){
+
+  uint8_t command[] = {
+        PN532_COMMAND_TGINITASTARGET,
+        5,                  // MODE: PICC only, Passive only
+
+        0x04, 0x00,         // SENS_RES
+        0x00, 0x00, 0x00,   // 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(uidPtr != 0){  // if uid is set copy 3 bytes to nfcid1
+    memcpy(command + 4, uidPtr, 3);
+  }
+
+  if(1 != pn532.tgInitAsTarget(command,sizeof(command), tgInitAsTargetTimeout)){
+    DMSG("tgInitAsTarget failed or timed out!");
+    return false;
+  }
+
+  uint8_t compatibility_container[] = {
+    0, 0x0F,
+    0x20,
+    0, 0x54,
+    0, 0xFF,
+    0x04,       // T
+    0x06,       // L
+    0xE1, 0x04, // File identifier
+    ((NDEF_MAX_LENGTH & 0xFF00) >> 8), (NDEF_MAX_LENGTH & 0xFF), // maximum NDEF file size
+    0x00,       // read access 0x0 = granted
+    0x00        // write access 0x0 = granted | 0xFF = deny
+  };
+
+  if(tagWriteable == false){
+    compatibility_container[14] = 0xFF;
+  }
+
+  tagWrittenByInitiator = false;
+
+  uint8_t rwbuf[128];
+  uint8_t sendlen;
+  int16_t status;
+  tag_file currentFile = NONE;
+  uint16_t cc_size = sizeof(compatibility_container);
+  bool runLoop = true;
+
+  while(runLoop){
+    status = pn532.tgGetData(rwbuf, sizeof(rwbuf));
+    if(status < 0){
+      DMSG("tgGetData failed!\n");
+      pn532.inRelease();
+      return true;
+    }
+
+    uint8_t p1 = rwbuf[C_APDU_P1];
+    uint8_t p2 = rwbuf[C_APDU_P2];
+    uint8_t lc = rwbuf[C_APDU_LC];
+    uint16_t p1p2_length = ((int16_t) p1 << 8) + p2;
+
+    switch(rwbuf[C_APDU_INS]){
+    case ISO7816_SELECT_FILE:
+      switch(p1){
+      case C_APDU_P1_SELECT_BY_ID:
+	if(p2 != 0x0c){
+	  DMSG("C_APDU_P2 != 0x0c\n");
+	  setResponse(COMMAND_COMPLETE, rwbuf, &sendlen);
+	} else if(lc == 2 && rwbuf[C_APDU_DATA] == 0xE1 && (rwbuf[C_APDU_DATA+1] == 0x03 || rwbuf[C_APDU_DATA+1] == 0x04)){
+	  setResponse(COMMAND_COMPLETE, rwbuf, &sendlen);
+	  if(rwbuf[C_APDU_DATA+1] == 0x03){
+	    currentFile = CC;
+	  } else if(rwbuf[C_APDU_DATA+1] == 0x04){
+	    currentFile = NDEF;
+	  }
+	} else {
+	  setResponse(TAG_NOT_FOUND, rwbuf, &sendlen);
+	}
+	break;
+      case C_APDU_P1_SELECT_BY_NAME: 
+        const uint8_t ndef_tag_application_name_v2[] = {0, 0x7, 0xD2, 0x76, 0x00, 0x00, 0x85, 0x01, 0x01 };
+	if(0 == memcmp(ndef_tag_application_name_v2, rwbuf + C_APDU_P2, sizeof(ndef_tag_application_name_v2))){
+	  setResponse(COMMAND_COMPLETE, rwbuf, &sendlen);
+	} else{
+	  DMSG("function not supported\n");
+	  setResponse(FUNCTION_NOT_SUPPORTED, rwbuf, &sendlen);
+	} 
+	break;
+      }
+      break;
+    case ISO7816_READ_BINARY:
+      switch(currentFile){
+      case NONE:
+	setResponse(TAG_NOT_FOUND, rwbuf, &sendlen);
+	break;
+      case CC:
+	if( p1p2_length > NDEF_MAX_LENGTH){
+	  setResponse(END_OF_FILE_BEFORE_REACHED_LE_BYTES, rwbuf, &sendlen);
+	}else {
+	  memcpy(rwbuf,compatibility_container + p1p2_length, lc);
+	  setResponse(COMMAND_COMPLETE, rwbuf + lc, &sendlen, lc);
+	}
+	break;
+      case NDEF:
+	if( p1p2_length > NDEF_MAX_LENGTH){
+	  setResponse(END_OF_FILE_BEFORE_REACHED_LE_BYTES, rwbuf, &sendlen);
+	}else {
+	  memcpy(rwbuf, ndef_file + p1p2_length, lc);
+	  setResponse(COMMAND_COMPLETE, rwbuf + lc, &sendlen, lc);
+	}
+	break;
+      }
+      break;    
+    case ISO7816_UPDATE_BINARY:
+      if(!tagWriteable){
+	  setResponse(FUNCTION_NOT_SUPPORTED, rwbuf, &sendlen);
+      } else{      
+	if( p1p2_length > NDEF_MAX_LENGTH){
+	  setResponse(MEMORY_FAILURE, rwbuf, &sendlen);
+	}
+	else{
+	  memcpy(ndef_file + p1p2_length, rwbuf + C_APDU_DATA, lc);
+	  setResponse(COMMAND_COMPLETE, rwbuf, &sendlen);
+	  tagWrittenByInitiator = true;
+      
+      uint16_t ndef_length = (ndef_file[0] << 8) + ndef_file[1];
+      if ((ndef_length > 0) && (updateNdefCallback != 0)) {
+        updateNdefCallback(ndef_file + 2, ndef_length);
+      }
+	}
+      }
+      break;
+    default:
+      DMSG("Command not supported!");
+      DMSG_HEX(rwbuf[C_APDU_INS]);
+      DMSG("\n");
+      setResponse(FUNCTION_NOT_SUPPORTED, rwbuf, &sendlen);
+    }
+    status = pn532.tgSetData(rwbuf, sendlen);
+    if(status < 0){
+      DMSG("tgSetData failed\n!");
+      pn532.inRelease();
+      return true;
+    }
+  }
+  pn532.inRelease();
+  return true;
+}
+
+void EmulateTag::setResponse(responseCommand cmd, uint8_t* buf, uint8_t* sendlen, uint8_t sendlenOffset){
+  switch(cmd){
+  case COMMAND_COMPLETE:
+    buf[0] = R_APDU_SW1_COMMAND_COMPLETE;
+    buf[1] = R_APDU_SW2_COMMAND_COMPLETE;
+    *sendlen = 2 + sendlenOffset;
+    break;
+  case TAG_NOT_FOUND:
+    buf[0] = R_APDU_SW1_NDEF_TAG_NOT_FOUND;
+    buf[1] = R_APDU_SW2_NDEF_TAG_NOT_FOUND;
+    *sendlen = 2;    
+    break;
+  case FUNCTION_NOT_SUPPORTED:
+    buf[0] = R_APDU_SW1_FUNCTION_NOT_SUPPORTED;
+    buf[1] = R_APDU_SW2_FUNCTION_NOT_SUPPORTED;
+    *sendlen = 2; 
+    break;
+  case MEMORY_FAILURE:
+    buf[0] = R_APDU_SW1_MEMORY_FAILURE;
+    buf[1] = R_APDU_SW2_MEMORY_FAILURE;
+    *sendlen = 2;
+    break;
+  case END_OF_FILE_BEFORE_REACHED_LE_BYTES:
+    buf[0] = R_APDU_SW1_END_OF_FILE_BEFORE_REACHED_LE_BYTES;
+    buf[1] = R_APDU_SW2_END_OF_FILE_BEFORE_REACHED_LE_BYTES;
+    *sendlen= 2;
+    break;
+  }
+}
@@ -0,0 +1,71 @@
+/**************************************************************************/
+/*!
+    @file     emulatetag.h
+    @author   Armin Wieser
+    @license  BSD
+
+    Implemented using NFC forum documents & library of libnfc
+*/
+/**************************************************************************/
+
+#ifndef __EMULATETAG_H__
+#define __EMULATETAG_H__
+
+#include "PN532.h"
+
+#define NDEF_MAX_LENGTH 128  // altough ndef can handle up to 0xfffe in size, arduino cannot.
+typedef enum {COMMAND_COMPLETE, TAG_NOT_FOUND, FUNCTION_NOT_SUPPORTED, MEMORY_FAILURE, END_OF_FILE_BEFORE_REACHED_LE_BYTES} responseCommand;
+
+class EmulateTag{
+
+public:
+EmulateTag(PN532Interface &interface) : pn532(interface), uidPtr(0), tagWrittenByInitiator(false), tagWriteable(true), updateNdefCallback(0) { }
+  
+  bool init();
+
+  bool emulate(const uint16_t tgInitAsTargetTimeout = 0);
+
+  /*
+   * @param uid pointer to byte array of length 3 (uid is 4 bytes - first byte is fixed) or zero for uid 
+   */
+  void setUid(uint8_t* uid = 0);
+
+  void setNdefFile(const uint8_t* ndef, const int16_t ndefLength);
+
+  void getContent(uint8_t** buf, uint16_t* length){
+    *buf = ndef_file + 2; // first 2 bytes = length
+    *length = (ndef_file[0] << 8) + ndef_file[1];
+  }
+
+  bool writeOccured(){
+    return tagWrittenByInitiator;
+  }
+
+  void setTagWriteable(bool setWriteable){
+    tagWriteable = setWriteable;
+  }
+
+  uint8_t* getNdefFilePtr(){
+    return ndef_file;
+  }
+
+  uint8_t getNdefMaxLength(){
+    return NDEF_MAX_LENGTH;
+  }
+
+  void attach(void (*func)(uint8_t *buf, uint16_t length)) {
+    updateNdefCallback = func;
+  };
+
+private:
+  PN532 pn532;
+  uint8_t ndef_file[NDEF_MAX_LENGTH];
+  uint8_t* uidPtr;
+  bool tagWrittenByInitiator;
+  bool tagWriteable;
+  void (*updateNdefCallback)(uint8_t *ndef, uint16_t length);
+
+  void setResponse(responseCommand cmd, uint8_t* buf, uint8_t* sendlen, uint8_t sendlenOffset = 0);
+};
+
+#endif
@@ -0,0 +1,135 @@
+#include <SPI.h>
+#include <PN532_SPI.h>
+#include <PN532Interface.h>
+#include <PN532.h>
+
+PN532_SPI pn532spi(SPI, 10);
+PN532 nfc(pn532spi);
+
+
+void setup()
+{    
+    Serial.begin(115200);
+    Serial.println("-------Peer to Peer HCE--------");
+    
+    nfc.begin();
+    
+    uint32_t versiondata = nfc.getFirmwareVersion();
+    if (! versiondata) {
+      Serial.print("Didn't find PN53x board");
+      while (1); // halt
+    }
+    
+    // Got ok data, print it out!
+    Serial.print("Found chip PN5"); Serial.println((versiondata>>24) & 0xFF, HEX); 
+    Serial.print("Firmware ver. "); Serial.print((versiondata>>16) & 0xFF, DEC); 
+    Serial.print('.'); Serial.println((versiondata>>8) & 0xFF, DEC);
+    
+    // Set the max number of retry attempts to read from a card
+    // This prevents us from waiting forever for a card, which is
+    // the default behaviour of the PN532.
+    //nfc.setPassiveActivationRetries(0xFF);
+    
+    // configure board to read RFID tags
+    nfc.SAMConfig();
+}
+
+void loop()
+{
+  bool success;
+  
+  uint8_t responseLength = 32;
+  
+  Serial.println("Waiting for an ISO14443A card");
+  
+  // set shield to inListPassiveTarget
+  success = nfc.inListPassiveTarget();
+
+  if(success) {
+   
+     Serial.println("Found something!");
+                  
+    uint8_t selectApdu[] = { 0x00, /* CLA */
+                              0xA4, /* INS */
+                              0x04, /* P1  */
+                              0x00, /* P2  */
+                              0x07, /* Length of AID  */
+                              0xF0, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, /* AID defined on Android App */
+                              0x00  /* Le  */ };
+                              
+    uint8_t response[32];  
+     
+    success = nfc.inDataExchange(selectApdu, sizeof(selectApdu), response, &responseLength);
+    
+    if(success) {
+      
+      Serial.print("responseLength: "); Serial.println(responseLength);
+       
+      nfc.PrintHexChar(response, responseLength);
+      
+      do {
+        uint8_t apdu[] = "Hello from Arduino";
+        uint8_t back[32];
+        uint8_t length = 32; 
+
+        success = nfc.inDataExchange(apdu, sizeof(apdu), back, &length);
+        
+        if(success) {
+         
+          Serial.print("responseLength: "); Serial.println(length);
+           
+          nfc.PrintHexChar(back, length);
+        }
+        else {
+          
+          Serial.println("Broken connection?"); 
+        }
+      }
+      while(success);
+    }
+    else {
+     
+      Serial.println("Failed sending SELECT AID"); 
+    }
+  }
+  else {
+   
+    Serial.println("Didn't find anything!");
+  }
+
+  delay(1000);
+}
+
+void printResponse(uint8_t *response, uint8_t responseLength) {
+  
+   String respBuffer;
+
+    for (int i = 0; i < responseLength; i++) {
+      
+      if (response[i] < 0x10) 
+        respBuffer = respBuffer + "0"; //Adds leading zeros if hex value is smaller than 0x10
+      
+      respBuffer = respBuffer + String(response[i], HEX) + " ";                        
+    }
+
+    Serial.print("response: "); Serial.println(respBuffer);
+}
+
+void setupNFC() {
+ 
+  nfc.begin();
+    
+  uint32_t versiondata = nfc.getFirmwareVersion();
+  if (! versiondata) {
+    Serial.print("Didn't find PN53x board");
+    while (1); // halt
+  }
+  
+  // Got ok data, print it out!
+  Serial.print("Found chip PN5"); Serial.println((versiondata>>24) & 0xFF, HEX); 
+  Serial.print("Firmware ver. "); Serial.print((versiondata>>16) & 0xFF, DEC); 
+  Serial.print('.'); Serial.println((versiondata>>8) & 0xFF, DEC);
+  
+  // configure board to read RFID tags
+  nfc.SAMConfig(); 
+}
@@ -0,0 +1,69 @@
+
+#include "SPI.h"
+#include "PN532_SPI.h"
+#include "emulatetag.h"
+#include "NdefMessage.h"
+
+PN532_SPI pn532spi(SPI, 10);
+EmulateTag nfc(pn532spi);
+
+uint8_t ndefBuf[120];
+NdefMessage message;
+int messageSize;
+
+uint8_t uid[3] = { 0x12, 0x34, 0x56 };
+
+void setup()
+{
+  Serial.begin(115200);
+  Serial.println("------- Emulate Tag --------");
+  
+  message = NdefMessage();
+  message.addUriRecord("http://www.seeedstudio.com");
+  messageSize = message.getEncodedSize();
+  if (messageSize > sizeof(ndefBuf)) {
+      Serial.println("ndefBuf is too small");
+      while (1) { }
+  }
+  
+  Serial.print("Ndef encoded message size: ");
+  Serial.println(messageSize);
+
+  message.encode(ndefBuf);
+  
+  // comment out this command for no ndef message
+  nfc.setNdefFile(ndefBuf, messageSize);
+  
+  // uid must be 3 bytes!
+  nfc.setUid(uid);
+  
+  nfc.init();
+}
+
+void loop(){
+    // uncomment for overriding ndef in case a write to this tag occured
+    //nfc.setNdefFile(ndefBuf, messageSize); 
+    
+    // start emulation (blocks)
+    nfc.emulate();
+        
+    // or start emulation with timeout
+    /*if(!nfc.emulate(1000)){ // timeout 1 second
+      Serial.println("timed out");
+    }*/
+    
+    // deny writing to the tag
+    // nfc.setTagWriteable(false);
+    
+    if(nfc.writeOccured()){
+       Serial.println("\nWrite occured !");
+       uint8_t* tag_buf;
+       uint16_t length;
+       
+       nfc.getContent(&tag_buf, &length);
+       NdefMessage msg = NdefMessage(tag_buf, length);
+       msg.print();
+    }
+
+    delay(1000);
+}
@@ -0,0 +1,77 @@
+/**************************************************************************/
+/*! 
+    This example will attempt to connect to an ISO14443A
+    card or tag and retrieve some basic information about it
+    that can be used to determine what type of card it is.   
+   
+    Note that you need the baud rate to be 115200 because we need to print
+    out the data and read from the card at the same time!
+
+    To enable debug message, define DEBUG in PN532/PN532_debug.h
+    
+*/
+/**************************************************************************/
+
+#include <SPI.h>
+#include <PN532_SPI.h>
+#include "PN532.h"
+
+PN532_SPI pn532spi(SPI, 10);
+PN532 nfc(pn532spi);
+
+void setup(void) {
+  Serial.begin(115200);
+  Serial.println("Hello!");
+
+  nfc.begin();
+
+  uint32_t versiondata = nfc.getFirmwareVersion();
+  if (! versiondata) {
+    Serial.print("Didn't find PN53x board");
+    while (1); // halt
+  }
+  
+  // Got ok data, print it out!
+  Serial.print("Found chip PN5"); Serial.println((versiondata>>24) & 0xFF, HEX); 
+  Serial.print("Firmware ver. "); Serial.print((versiondata>>16) & 0xFF, DEC); 
+  Serial.print('.'); Serial.println((versiondata>>8) & 0xFF, DEC);
+  
+  // Set the max number of retry attempts to read from a card
+  // This prevents us from waiting forever for a card, which is
+  // the default behaviour of the PN532.
+  nfc.setPassiveActivationRetries(0xFF);
+  
+  // configure board to read RFID tags
+  nfc.SAMConfig();
+    
+  Serial.println("Waiting for an ISO14443A card");
+}
+
+void loop(void) {
+  boolean success;
+  uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 };  // Buffer to store the returned UID
+  uint8_t uidLength;                        // Length of the UID (4 or 7 bytes depending on ISO14443A card type)
+  
+  // Wait for an ISO14443A type cards (Mifare, etc.).  When one is found
+  // 'uid' will be populated with the UID, and uidLength will indicate
+  // if the uid is 4 bytes (Mifare Classic) or 7 bytes (Mifare Ultralight)
+  success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, &uid[0], &uidLength);
+  
+  if (success) {
+    Serial.println("Found a card!");
+    Serial.print("UID Length: ");Serial.print(uidLength, DEC);Serial.println(" bytes");
+    Serial.print("UID Value: ");
+    for (uint8_t i=0; i < uidLength; i++) 
+    {
+      Serial.print(" 0x");Serial.print(uid[i], HEX); 
+    }
+    Serial.println("");
+    // Wait 1 second before continuing
+    delay(1000);
+  }
+  else
+  {
+    // PN532 probably timed out waiting for a card
+    Serial.println("Timed out waiting for a card");
+  }
+}
 \ No newline at end of file
@@ -0,0 +1,170 @@
+/**************************************************************************/
+/*!
+    This example attempts to format a clean Mifare Classic 1K card as
+    an NFC Forum tag (to store NDEF messages that can be read by any
+    NFC enabled Android phone, etc.)
+
+    Note that you need the baud rate to be 115200 because we need to print
+    out the data and read from the card at the same time!
+
+    To enable debug message, define DEBUG in PN532/PN532_debug.h
+*/
+/**************************************************************************/
+
+#include <SPI.h>
+#include <PN532_SPI.h>
+#include "PN532.h"
+
+PN532_SPI pn532spi(SPI, 10);
+PN532 nfc(pn532spi);
+
+/*
+    We can encode many different kinds of pointers to the card,
+    from a URL, to an Email address, to a phone number, and many more
+    check the library header .h file to see the large # of supported
+    prefixes!
+*/
+// For a http://www. url:
+const char * url = "seeedstudio.com";
+uint8_t ndefprefix = NDEF_URIPREFIX_HTTP_WWWDOT;
+
+// for an email address
+//const char * url = "mail@example.com";
+//uint8_t ndefprefix = NDEF_URIPREFIX_MAILTO;
+
+// for a phone number
+//const char * url = "+1 212 555 1212";
+//uint8_t ndefprefix = NDEF_URIPREFIX_TEL;
+
+
+void setup(void) {
+  Serial.begin(115200);
+  Serial.println("Looking for PN532...");
+
+  nfc.begin();
+
+  uint32_t versiondata = nfc.getFirmwareVersion();
+  if (! versiondata) {
+    Serial.print("Didn't find PN53x board");
+    while (1); // halt
+  }
+
+  // Got ok data, print it out!
+  Serial.print("Found chip PN5"); Serial.println((versiondata>>24) & 0xFF, HEX);
+  Serial.print("Firmware ver. "); Serial.print((versiondata>>16) & 0xFF, DEC);
+  Serial.print('.'); Serial.println((versiondata>>8) & 0xFF, DEC);
+
+  // configure board to read RFID tags
+  nfc.SAMConfig();
+}
+
+void loop(void) {
+  uint8_t success;                          // Flag to check if there was an error with the PN532
+  uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 };  // Buffer to store the returned UID
+  uint8_t uidLength;                        // Length of the UID (4 or 7 bytes depending on ISO14443A card type)
+  bool authenticated = false;               // Flag to indicate if the sector is authenticated
+
+  // Use the default key
+  uint8_t keya[6] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
+
+  Serial.println("");
+  Serial.println("PLEASE NOTE: Formatting your card for NDEF records will change the");
+  Serial.println("authentication keys.  To reformat your NDEF tag as a clean Mifare");
+  Serial.println("Classic tag, use the mifareclassic_ndeftoclassic example!");
+  Serial.println("");
+  Serial.println("Place your Mifare Classic card on the reader to format with NDEF");
+  Serial.println("and press any key to continue ...");
+  // Wait for user input before proceeding
+  while (!Serial.available());
+  // a key was pressed1
+  while (Serial.available()) Serial.read();
+
+  // Wait for an ISO14443A type card (Mifare, etc.).  When one is found
+  // 'uid' will be populated with the UID, and uidLength will indicate
+  // if the uid is 4 bytes (Mifare Classic) or 7 bytes (Mifare Ultralight)
+  success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength);
+
+  if (success)
+  {
+    // Display some basic information about the card
+    Serial.println("Found an ISO14443A card");
+    Serial.print("  UID Length: ");Serial.print(uidLength, DEC);Serial.println(" bytes");
+    Serial.print("  UID Value: ");
+    nfc.PrintHex(uid, uidLength);
+    for (uint8_t i = 0; i < uidLength; i++) {
+      Serial.print(uid[i], HEX);
+      Serial.print(' ');
+    }
+    Serial.println("");
+
+    // Make sure this is a Mifare Classic card
+    if (uidLength != 4)
+    {
+      Serial.println("Ooops ... this doesn't seem to be a Mifare Classic card!");
+      return;
+    }
+
+    // We probably have a Mifare Classic card ...
+    Serial.println("Seems to be a Mifare Classic card (4 byte UID)");
+
+    // Try to format the card for NDEF data
+    success = nfc.mifareclassic_AuthenticateBlock (uid, uidLength, 0, 0, keya);
+    if (!success)
+    {
+      Serial.println("Unable to authenticate block 0 to enable card formatting!");
+      return;
+    }
+    success = nfc.mifareclassic_FormatNDEF();
+    if (!success)
+    {
+      Serial.println("Unable to format the card for NDEF");
+      return;
+    }
+
+    Serial.println("Card has been formatted for NDEF data using MAD1");
+
+    // Try to authenticate block 4 (first block of sector 1) using our key
+    success = nfc.mifareclassic_AuthenticateBlock (uid, uidLength, 4, 0, keya);
+
+    // Make sure the authentification process didn't fail
+    if (!success)
+    {
+      Serial.println("Authentication failed.");
+      return;
+    }
+
+    // Try to write a URL
+    Serial.println("Writing URI to sector 1 as an NDEF Message");
+
+    // Authenticated seems to have worked
+    // Try to write an NDEF record to sector 1
+    // Use 0x01 for the URI Identifier Code to prepend "http://www."
+    // to the url (and save some space).  For information on URI ID Codes
+    // see http://www.ladyada.net/wiki/private/articlestaging/nfc/ndef
+    if (strlen(url) > 38)
+    {
+      // The length is also checked in the WriteNDEFURI function, but lets
+      // warn users here just in case they change the value and it's bigger
+      // than it should be
+      Serial.println("URI is too long ... must be less than 38 characters long");
+      return;
+    }
+
+    // URI is within size limits ... write it to the card and report success/failure
+    success = nfc.mifareclassic_WriteNDEFURI(1, ndefprefix, url);
+    if (success)
+    {
+      Serial.println("NDEF URI Record written to sector 1");
+    }
+    else
+    {
+      Serial.println("NDEF Record creation failed! :(");
+    }
+  }
+
+  // Wait a bit before trying again
+  Serial.println("\n\nDone!");
+  delay(1000);
+  Serial.flush();
+  while(Serial.available()) Serial.read();
+}
 \ No newline at end of file
@@ -0,0 +1,157 @@
+/**************************************************************************/
+/*!
+    This example attempts to dump the contents of a Mifare Classic 1K card
+
+    Note that you need the baud rate to be 115200 because we need to print
+    out the data and read from the card at the same time!
+
+    To enable debug message, define DEBUG in PN532/PN532_debug.h
+*/
+/**************************************************************************/
+
+#include <SPI.h>
+#include <PN532_SPI.h>
+#include "PN532.h"
+
+PN532_SPI pn532spi(SPI, 10);
+PN532 nfc(pn532spi);
+
+void setup(void) {
+  // has to be fast to dump the entire memory contents!
+  Serial.begin(115200);
+  Serial.println("Looking for PN532...");
+
+  nfc.begin();
+
+  uint32_t versiondata = nfc.getFirmwareVersion();
+  if (! versiondata) {
+    Serial.print("Didn't find PN53x board");
+    while (1); // halt
+  }
+  // Got ok data, print it out!
+  Serial.print("Found chip PN5"); Serial.println((versiondata>>24) & 0xFF, HEX);
+  Serial.print("Firmware ver. "); Serial.print((versiondata>>16) & 0xFF, DEC);
+  Serial.print('.'); Serial.println((versiondata>>8) & 0xFF, DEC);
+
+  // configure board to read RFID tags
+  nfc.SAMConfig();
+
+  Serial.println("Waiting for an ISO14443A Card ...");
+}
+
+
+void loop(void) {
+  uint8_t success;                          // Flag to check if there was an error with the PN532
+  uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 };  // Buffer to store the returned UID
+  uint8_t uidLength;                        // Length of the UID (4 or 7 bytes depending on ISO14443A card type)
+  uint8_t currentblock;                     // Counter to keep track of which block we're on
+  bool authenticated = false;               // Flag to indicate if the sector is authenticated
+  uint8_t data[16];                         // Array to store block data during reads
+
+  // Keyb on NDEF and Mifare Classic should be the same
+  uint8_t keyuniversal[6] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
+
+  // Wait for an ISO14443A type cards (Mifare, etc.).  When one is found
+  // 'uid' will be populated with the UID, and uidLength will indicate
+  // if the uid is 4 bytes (Mifare Classic) or 7 bytes (Mifare Ultralight)
+  success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength);
+
+  if (success) {
+    // Display some basic information about the card
+    Serial.println("Found an ISO14443A card");
+    Serial.print("  UID Length: ");Serial.print(uidLength, DEC);Serial.println(" bytes");
+    Serial.print("  UID Value: ");
+    for (uint8_t i = 0; i < uidLength; i++) {
+      Serial.print(uid[i], HEX);
+      Serial.print(' ');
+    }
+    Serial.println("");
+
+    if (uidLength == 4)
+    {
+      // We probably have a Mifare Classic card ...
+      Serial.println("Seems to be a Mifare Classic card (4 byte UID)");
+
+      // Now we try to go through all 16 sectors (each having 4 blocks)
+      // authenticating each sector, and then dumping the blocks
+      for (currentblock = 0; currentblock < 64; currentblock++)
+      {
+        // Check if this is a new block so that we can reauthenticate
+        if (nfc.mifareclassic_IsFirstBlock(currentblock)) authenticated = false;
+
+        // If the sector hasn't been authenticated, do so first
+        if (!authenticated)
+        {
+          // Starting of a new sector ... try to to authenticate
+          Serial.print("------------------------Sector ");Serial.print(currentblock/4, DEC);Serial.println("-------------------------");
+          if (currentblock == 0)
+          {
+              // This will be 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF for Mifare Classic (non-NDEF!)
+              // or 0xA0 0xA1 0xA2 0xA3 0xA4 0xA5 for NDEF formatted cards using key a,
+              // but keyb should be the same for both (0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+              success = nfc.mifareclassic_AuthenticateBlock (uid, uidLength, currentblock, 1, keyuniversal);
+          }
+          else
+          {
+              // This will be 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF for Mifare Classic (non-NDEF!)
+              // or 0xD3 0xF7 0xD3 0xF7 0xD3 0xF7 for NDEF formatted cards using key a,
+              // but keyb should be the same for both (0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+              success = nfc.mifareclassic_AuthenticateBlock (uid, uidLength, currentblock, 1, keyuniversal);
+          }
+          if (success)
+          {
+            authenticated = true;
+          }
+          else
+          {
+            Serial.println("Authentication error");
+          }
+        }
+        // If we're still not authenticated just skip the block
+        if (!authenticated)
+        {
+          Serial.print("Block ");Serial.print(currentblock, DEC);Serial.println(" unable to authenticate");
+        }
+        else
+        {
+          // Authenticated ... we should be able to read the block now
+          // Dump the data into the 'data' array
+          success = nfc.mifareclassic_ReadDataBlock(currentblock, data);
+          if (success)
+          {
+            // Read successful
+            Serial.print("Block ");Serial.print(currentblock, DEC);
+            if (currentblock < 10)
+            {
+              Serial.print("  ");
+            }
+            else
+            {
+              Serial.print(" ");
+            }
+            // Dump the raw data
+            nfc.PrintHexChar(data, 16);
+          }
+          else
+          {
+            // Oops ... something happened
+            Serial.print("Block ");Serial.print(currentblock, DEC);
+            Serial.println(" unable to read this block");
+          }
+        }
+      }
+    }
+    else
+    {
+      Serial.println("Ooops ... this doesn't seem to be a Mifare Classic card!");
+    }
+  }
+  // Wait a bit before trying again
+  Serial.println("\n\nSend a character to run the mem dumper again!");
+  Serial.flush();
+  while (!Serial.available());
+  while (Serial.available()) {
+  Serial.read();
+  }
+  Serial.flush();
+}
 \ No newline at end of file
@@ -0,0 +1,172 @@
+/**************************************************************************/
+/*! 
+    This examples attempts to take a Mifare Classic 1K card that has been
+    formatted for NDEF messages using mifareclassic_formatndef, and resets
+    the authentication keys back to the Mifare Classic defaults
+
+    To enable debug message, define DEBUG in PN532/PN532_debug.h
+*/
+/**************************************************************************/
+
+#include <SPI.h>
+#include <PN532_SPI.h>
+#include "PN532.h"
+
+PN532_SPI pn532spi(SPI, 10);
+PN532 nfc(pn532spi);
+
+
+#define NR_SHORTSECTOR          (32)    // Number of short sectors on Mifare 1K/4K
+#define NR_LONGSECTOR           (8)     // Number of long sectors on Mifare 4K
+#define NR_BLOCK_OF_SHORTSECTOR (4)     // Number of blocks in a short sector
+#define NR_BLOCK_OF_LONGSECTOR  (16)    // Number of blocks in a long sector
+
+// Determine the sector trailer block based on sector number
+#define BLOCK_NUMBER_OF_SECTOR_TRAILER(sector) (((sector)<NR_SHORTSECTOR)? \
+  ((sector)*NR_BLOCK_OF_SHORTSECTOR + NR_BLOCK_OF_SHORTSECTOR-1):\
+  (NR_SHORTSECTOR*NR_BLOCK_OF_SHORTSECTOR + (sector-NR_SHORTSECTOR)*NR_BLOCK_OF_LONGSECTOR + NR_BLOCK_OF_LONGSECTOR-1))
+
+// Determine the sector's first block based on the sector number
+#define BLOCK_NUMBER_OF_SECTOR_1ST_BLOCK(sector) (((sector)<NR_SHORTSECTOR)? \
+  ((sector)*NR_BLOCK_OF_SHORTSECTOR):\
+  (NR_SHORTSECTOR*NR_BLOCK_OF_SHORTSECTOR + (sector-NR_SHORTSECTOR)*NR_BLOCK_OF_LONGSECTOR))
+
+// The default Mifare Classic key
+static const uint8_t KEY_DEFAULT_KEYAB[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+
+void setup(void) {
+  Serial.begin(115200);
+  Serial.println("Looking for PN532...");
+
+  nfc.begin();
+
+  uint32_t versiondata = nfc.getFirmwareVersion();
+  if (! versiondata) {
+    Serial.print("Didn't find PN53x board");
+    while (1); // halt
+  }
+  
+  // Got ok data, print it out!
+  Serial.print("Found chip PN5"); Serial.println((versiondata>>24) & 0xFF, HEX); 
+  Serial.print("Firmware ver. "); Serial.print((versiondata>>16) & 0xFF, DEC); 
+  Serial.print('.'); Serial.println((versiondata>>8) & 0xFF, DEC);
+  
+  // configure board to read RFID tags
+  nfc.SAMConfig();
+}
+
+void loop(void) {
+  uint8_t success;                          // Flag to check if there was an error with the PN532
+  uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 };  // Buffer to store the returned UID
+  uint8_t uidLength;                        // Length of the UID (4 or 7 bytes depending on ISO14443A card type)
+  bool authenticated = false;               // Flag to indicate if the sector is authenticated
+  uint8_t blockBuffer[16];                  // Buffer to store block contents
+  uint8_t blankAccessBits[3] = { 0xff, 0x07, 0x80 };
+  uint8_t idx = 0;
+  uint8_t numOfSector = 16;                 // Assume Mifare Classic 1K for now (16 4-block sectors)
+  
+  Serial.println("Place your NDEF formatted Mifare Classic 1K card on the reader");
+  Serial.println("and press any key to continue ...");
+  
+  // Wait for user input before proceeding
+  while (!Serial.available());
+  while (Serial.available()) Serial.read();
+    
+  // Wait for an ISO14443A type card (Mifare, etc.).  When one is found
+  // 'uid' will be populated with the UID, and uidLength will indicate
+  // if the uid is 4 bytes (Mifare Classic) or 7 bytes (Mifare Ultralight)
+  success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength);
+
+  if (success) 
+  {
+    // We seem to have a tag ...
+    // Display some basic information about it
+    Serial.println("Found an ISO14443A card/tag");
+    Serial.print("  UID Length: ");Serial.print(uidLength, DEC);Serial.println(" bytes");
+    Serial.print("  UID Value: ");
+    nfc.PrintHex(uid, uidLength);
+    Serial.println("");
+    
+    // Make sure this is a Mifare Classic card
+    if (uidLength != 4)
+    {
+      Serial.println("Ooops ... this doesn't seem to be a Mifare Classic card!"); 
+      return;
+    }    
+    
+    Serial.println("Seems to be a Mifare Classic card (4 byte UID)");
+    Serial.println("");
+    Serial.println("Reformatting card for Mifare Classic (please don't touch it!) ... ");
+
+    // Now run through the card sector by sector
+    for (idx = 0; idx < numOfSector; idx++)
+    {
+      // Step 1: Authenticate the current sector using key B 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF
+      success = nfc.mifareclassic_AuthenticateBlock (uid, uidLength, BLOCK_NUMBER_OF_SECTOR_TRAILER(idx), 1, (uint8_t *)KEY_DEFAULT_KEYAB);
+      if (!success)
+      {
+        Serial.print("Authentication failed for sector "); Serial.println(numOfSector);
+        return;
+      }
+      
+      // Step 2: Write to the other blocks
+      if (idx == 16)
+      {
+        memset(blockBuffer, 0, sizeof(blockBuffer));
+        if (!(nfc.mifareclassic_WriteDataBlock((BLOCK_NUMBER_OF_SECTOR_TRAILER(idx)) - 3, blockBuffer)))
+        {
+          Serial.print("Unable to write to sector "); Serial.println(numOfSector);
+          return;
+        }
+      }
+      if ((idx == 0) || (idx == 16))
+      {
+        memset(blockBuffer, 0, sizeof(blockBuffer));
+        if (!(nfc.mifareclassic_WriteDataBlock((BLOCK_NUMBER_OF_SECTOR_TRAILER(idx)) - 2, blockBuffer)))
+        {
+          Serial.print("Unable to write to sector "); Serial.println(numOfSector);
+          return;
+        }
+      }
+      else
+      {
+        memset(blockBuffer, 0, sizeof(blockBuffer));
+        if (!(nfc.mifareclassic_WriteDataBlock((BLOCK_NUMBER_OF_SECTOR_TRAILER(idx)) - 3, blockBuffer)))
+        {
+          Serial.print("Unable to write to sector "); Serial.println(numOfSector);
+          return;
+        }
+        if (!(nfc.mifareclassic_WriteDataBlock((BLOCK_NUMBER_OF_SECTOR_TRAILER(idx)) - 2, blockBuffer)))
+        {
+          Serial.print("Unable to write to sector "); Serial.println(numOfSector);
+          return;
+        }
+      }
+      memset(blockBuffer, 0, sizeof(blockBuffer));
+      if (!(nfc.mifareclassic_WriteDataBlock((BLOCK_NUMBER_OF_SECTOR_TRAILER(idx)) - 1, blockBuffer)))
+      {
+        Serial.print("Unable to write to sector "); Serial.println(numOfSector);
+        return;
+      }
+      
+      // Step 3: Reset both keys to 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF
+      memcpy(blockBuffer, KEY_DEFAULT_KEYAB, sizeof(KEY_DEFAULT_KEYAB));
+      memcpy(blockBuffer + 6, blankAccessBits, sizeof(blankAccessBits));
+      blockBuffer[9] = 0x69;
+      memcpy(blockBuffer + 10, KEY_DEFAULT_KEYAB, sizeof(KEY_DEFAULT_KEYAB));
+
+      // Step 4: Write the trailer block
+      if (!(nfc.mifareclassic_WriteDataBlock((BLOCK_NUMBER_OF_SECTOR_TRAILER(idx)), blockBuffer)))
+      {
+        Serial.print("Unable to write trailer block of sector "); Serial.println(numOfSector);
+        return;
+      }
+    }
+  }
+  
+  // Wait a bit before trying again
+  Serial.println("\n\nDone!");
+  delay(1000);
+  Serial.flush();
+  while(Serial.available()) Serial.read();
+}
 \ No newline at end of file
@@ -0,0 +1,145 @@
+/**************************************************************************/
+/*!
+    Updates a sector that is already formatted for NDEF (using
+    mifareclassic_formatndef.pde for example), inserting a new url
+
+    To enable debug message, define DEBUG in PN532/PN532_debug.h
+*/
+/**************************************************************************/
+
+#include <SPI.h>
+#include <PN532_SPI.h>
+#include "PN532.h"
+
+PN532_SPI pn532spi(SPI, 10);
+PN532 nfc(pn532spi);
+
+
+
+/*  
+    We can encode many different kinds of pointers to the card,
+    from a URL, to an Email address, to a phone number, and many more
+    check the library header .h file to see the large # of supported
+    prefixes! 
+*/
+// For a http://www. url:
+const char * url = "seeedstudio.com";
+uint8_t ndefprefix = NDEF_URIPREFIX_HTTP_WWWDOT;
+
+// for an email address
+//const char * url = "mail@example.com";
+//uint8_t ndefprefix = NDEF_URIPREFIX_MAILTO;
+
+// for a phone number
+//const char * url = "+1 212 555 1212";
+//uint8_t ndefprefix = NDEF_URIPREFIX_TEL;
+
+
+void setup(void) {
+  Serial.begin(115200);
+  Serial.println("Looking for PN532...");
+
+  nfc.begin();
+
+  uint32_t versiondata = nfc.getFirmwareVersion();
+  if (! versiondata) {
+    Serial.print("Didn't find PN53x board");
+    while (1); // halt
+  }
+  
+  // Got ok data, print it out!
+  Serial.print("Found chip PN5"); Serial.println((versiondata>>24) & 0xFF, HEX); 
+  Serial.print("Firmware ver. "); Serial.print((versiondata>>16) & 0xFF, DEC); 
+  Serial.print('.'); Serial.println((versiondata>>8) & 0xFF, DEC);
+  
+  // configure board to read RFID tags
+  nfc.SAMConfig();
+}
+
+void loop(void) {
+  uint8_t success;                          // Flag to check if there was an error with the PN532
+  uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 };  // Buffer to store the returned UID
+  uint8_t uidLength;                        // Length of the UID (4 or 7 bytes depending on ISO14443A card type)
+  bool authenticated = false;               // Flag to indicate if the sector is authenticated
+
+  // Use the default NDEF keys (these would have have set by mifareclassic_formatndef.pde!)
+  uint8_t keya[6] = { 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5 };
+  uint8_t keyb[6] = { 0xD3, 0xF7, 0xD3, 0xF7, 0xD3, 0xF7 };
+
+  Serial.println("Place your NDEF formatted Mifare Classic card on the reader to update the");
+  Serial.println("NDEF record and press any key to continue ...");
+  // Wait for user input before proceeding
+  while (!Serial.available());
+  // a key was pressed1
+  while (Serial.available()) Serial.read();
+    
+  // Wait for an ISO14443A type card (Mifare, etc.).  When one is found
+  // 'uid' will be populated with the UID, and uidLength will indicate
+  // if the uid is 4 bytes (Mifare Classic) or 7 bytes (Mifare Ultralight)
+  success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength);
+  
+  if (success) 
+  {
+    // Display some basic information about the card
+    Serial.println("Found an ISO14443A card");
+    Serial.print("  UID Length: ");Serial.print(uidLength, DEC);Serial.println(" bytes");
+    Serial.print("  UID Value: ");
+    nfc.PrintHex(uid, uidLength);
+    Serial.println("");
+    
+    // Make sure this is a Mifare Classic card
+    if (uidLength != 4)
+    {
+      Serial.println("Ooops ... this doesn't seem to be a Mifare Classic card!"); 
+      return;
+    }
+    
+    // We probably have a Mifare Classic card ... 
+    Serial.println("Seems to be a Mifare Classic card (4 byte UID)");
+
+    // Check if this is an NDEF card (using first block of sector 1 from mifareclassic_formatndef.pde)
+    // Must authenticate on the first key using 0xD3 0xF7 0xD3 0xF7 0xD3 0xF7
+    success = nfc.mifareclassic_AuthenticateBlock (uid, uidLength, 4, 0, keyb);
+    if (!success)
+    {
+      Serial.println("Unable to authenticate block 4 ... is this card NDEF formatted?");
+      return;
+    }
+    
+    Serial.println("Authentication succeeded (seems to be an NDEF/NFC Forum tag) ...");
+
+    // Authenticated seems to have worked
+    // Try to write an NDEF record to sector 1
+    // Use 0x01 for the URI Identifier Code to prepend "http://www."
+    // to the url (and save some space).  For information on URI ID Codes
+    // see http://www.ladyada.net/wiki/private/articlestaging/nfc/ndef
+    if (strlen(url) > 38)
+    {
+      // The length is also checked in the WriteNDEFURI function, but lets
+      // warn users here just in case they change the value and it's bigger
+      // than it should be
+      Serial.println("URI is too long ... must be less than 38 characters!");
+      return;
+    }
+    
+    Serial.println("Updating sector 1 with URI as NDEF Message");
+    
+    // URI is within size limits ... write it to the card and report success/failure
+    success = nfc.mifareclassic_WriteNDEFURI(1, ndefprefix, url);
+    if (success)
+    {
+      Serial.println("NDEF URI Record written to sector 1");
+      Serial.println("");      
+    }
+    else
+    {
+      Serial.println("NDEF Record creation failed! :(");
+    }
+  }
+  
+  // Wait a bit before trying again
+  Serial.println("\n\nDone!");
+  delay(1000);
+  Serial.flush();
+  while(Serial.available()) Serial.read();
+}
@@ -0,0 +1,51 @@
+// snep_test.ino
+// send a SNEP message to adnroid and get a message from android
+
+#include "SPI.h"
+#include "PN532_SPI.h"
+#include "llcp.h"
+#include "snep.h"
+
+PN532_SPI pn532spi(SPI, 10);
+SNEP nfc(pn532spi);
+
+void setup()
+{
+    Serial.begin(115200);
+    Serial.println("-------Peer to Peer--------");
+}
+
+uint8_t message[] = {
+0xD2, 0xA, 0xB, 0x74,0x65, 0x78, 0x74, 0x2F, 0x70, 0x6C, 
+0x61, 0x69, 0x6E, 0x68, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x77, 
+0x6F, 0x72, 0x6C, 0x64};
+
+uint8_t buf[128];
+
+void loop()
+{
+
+    nfc.write(message, sizeof(message));
+    delay(3000);
+
+    int16_t len = nfc.read(buf, sizeof(buf));
+    if (len > 0) {
+      Serial.println("get a SNEP message:");
+      for (uint8_t i = 0; i < len; i++) {
+        Serial.print(buf[i], HEX);
+        Serial.print(' ');
+      }
+      Serial.print('\n');
+      for (uint8_t i = 0; i < len; i++) {
+        char c = buf[i];
+        if (c <= 0x1f || c > 0x7f) {
+          Serial.print('.');
+        } else {
+          Serial.print(c);
+        }
+      }
+      Serial.print('\n');
+    }
+    delay(3000);
+}
+
@@ -0,0 +1,55 @@
+// send a NDEF message to adnroid or get a NDEF message
+//
+// note: [NDEF library](https://github.com/Don/NDEF) is needed.
+
+#include "SPI.h"
+#include "PN532_SPI.h"
+#include "snep.h"
+#include "NdefMessage.h"
+
+PN532_SPI pn532spi(SPI, 10);
+SNEP nfc(pn532spi);
+uint8_t ndefBuf[128];
+
+void setup()
+{
+    Serial.begin(115200);
+    Serial.println("-------Peer to Peer--------");
+}
+
+void loop()
+{
+#if 1
+    Serial.println("Send a message to Android");
+    NdefMessage message = NdefMessage();
+    message.addUriRecord("http://www.seeedstudio.com");
+    int messageSize = message.getEncodedSize();
+    if (messageSize > sizeof(ndefBuf)) {
+        Serial.println("ndefBuf is too small");
+        while (1) {
+        }
+
+    }
+
+    message.encode(ndefBuf);
+    if (0 >= nfc.write(ndefBuf, messageSize)) {
+        Serial.println("Failed");
+    } else {
+        Serial.println("Success");
+    }
+
+    delay(3000);
+#else
+    Serial.println("Get a message from Android");
+    int msgSize = nfc.read(ndefBuf, sizeof(ndefBuf));
+    if (msgSize > 0) {
+        NdefMessage msg  = NdefMessage(ndefBuf, msgSize);
+        msg.print();
+        Serial.println("\nSuccess");
+    } else {
+        Serial.println("failed");
+    }
+    delay(3000);
+#endif
+}
+
@@ -0,0 +1,145 @@
+/**************************************************************************/
+/*! 
+    This example will wait for any ISO14443A card or tag, and
+    depending on the size of the UID will attempt to read from it.
+   
+    If the card has a 4-byte UID it is probably a Mifare
+    Classic card, and the following steps are taken:
+   
+    - Authenticate block 4 (the first block of Sector 1) using
+      the default KEYA of 0XFF 0XFF 0XFF 0XFF 0XFF 0XFF
+    - If authentication succeeds, we can then read any of the
+      4 blocks in that sector (though only block 4 is read here)
+	 
+    If the card has a 7-byte UID it is probably a Mifare
+    Ultralight card, and the 4 byte pages can be read directly.
+    Page 4 is read by default since this is the first 'general-
+    purpose' page on the tags.
+
+    To enable debug message, define DEBUG in PN532/PN532_debug.h
+*/
+/**************************************************************************/
+
+#include <SPI.h>
+#include <PN532_SPI.h>
+#include "PN532.h"
+
+PN532_SPI pn532spi(SPI, 10);
+PN532 nfc(pn532spi);
+
+void setup(void) {
+  Serial.begin(115200);
+  Serial.println("Hello!");
+
+  nfc.begin();
+
+  uint32_t versiondata = nfc.getFirmwareVersion();
+  if (! versiondata) {
+    Serial.print("Didn't find PN53x board");
+    while (1); // halt
+  }
+  // Got ok data, print it out!
+  Serial.print("Found chip PN5"); Serial.println((versiondata>>24) & 0xFF, HEX); 
+  Serial.print("Firmware ver. "); Serial.print((versiondata>>16) & 0xFF, DEC); 
+  Serial.print('.'); Serial.println((versiondata>>8) & 0xFF, DEC);
+  
+  // configure board to read RFID tags
+  nfc.SAMConfig();
+  
+  Serial.println("Waiting for an ISO14443A Card ...");
+}
+
+
+void loop(void) {
+  uint8_t success;
+  uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 };  // Buffer to store the returned UID
+  uint8_t uidLength;                        // Length of the UID (4 or 7 bytes depending on ISO14443A card type)
+    
+  // Wait for an ISO14443A type cards (Mifare, etc.).  When one is found
+  // 'uid' will be populated with the UID, and uidLength will indicate
+  // if the uid is 4 bytes (Mifare Classic) or 7 bytes (Mifare Ultralight)
+  success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength);
+  
+  if (success) {
+    // Display some basic information about the card
+    Serial.println("Found an ISO14443A card");
+    Serial.print("  UID Length: ");Serial.print(uidLength, DEC);Serial.println(" bytes");
+    Serial.print("  UID Value: ");
+    nfc.PrintHex(uid, uidLength);
+    Serial.println("");
+    
+    if (uidLength == 4)
+    {
+      // We probably have a Mifare Classic card ... 
+      Serial.println("Seems to be a Mifare Classic card (4 byte UID)");
+	  
+      // Now we need to try to authenticate it for read/write access
+      // Try with the factory default KeyA: 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF
+      Serial.println("Trying to authenticate block 4 with default KEYA value");
+      uint8_t keya[6] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
+	  
+	  // Start with block 4 (the first block of sector 1) since sector 0
+	  // contains the manufacturer data and it's probably better just
+	  // to leave it alone unless you know what you're doing
+      success = nfc.mifareclassic_AuthenticateBlock(uid, uidLength, 4, 0, keya);
+	  
+      if (success)
+      {
+        Serial.println("Sector 1 (Blocks 4..7) has been authenticated");
+        uint8_t data[16];
+		
+        // If you want to write something to block 4 to test with, uncomment
+		// the following line and this text should be read back in a minute
+        // data = { 'a', 'd', 'a', 'f', 'r', 'u', 'i', 't', '.', 'c', 'o', 'm', 0, 0, 0, 0};
+        // success = nfc.mifareclassic_WriteDataBlock (4, data);
+
+        // Try to read the contents of block 4
+        success = nfc.mifareclassic_ReadDataBlock(4, data);
+		
+        if (success)
+        {
+          // Data seems to have been read ... spit it out
+          Serial.println("Reading Block 4:");
+          nfc.PrintHexChar(data, 16);
+          Serial.println("");
+		  
+          // Wait a bit before reading the card again
+          delay(1000);
+        }
+        else
+        {
+          Serial.println("Ooops ... unable to read the requested block.  Try another key?");
+        }
+      }
+      else
+      {
+        Serial.println("Ooops ... authentication failed: Try another key?");
+      }
+    }
+    
+    if (uidLength == 7)
+    {
+      // We probably have a Mifare Ultralight card ...
+      Serial.println("Seems to be a Mifare Ultralight tag (7 byte UID)");
+	  
+      // Try to read the first general-purpose user page (#4)
+      Serial.println("Reading page 4");
+      uint8_t data[32];
+      success = nfc.mifareultralight_ReadPage (4, data);
+      if (success)
+      {
+        // Data seems to have been read ... spit it out
+        nfc.PrintHexChar(data, 4);
+        Serial.println("");
+		
+        // Wait a bit before reading the card again
+        delay(1000);
+      }
+      else
+      {
+        Serial.println("Ooops ... unable to read the requested page!?");
+      }
+    }
+  }
+}
+
@@ -0,0 +1,27 @@
+Software License Agreement (BSD License)
+
+Copyright (c) 2012, Adafruit Industries
+Copyright (c) 2013, Seeed Technology Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+3. Neither the name of the copyright holders nor the
+names of its contributors may be used to endorse or promote products
+derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
@@ -0,0 +1,309 @@
+
+#include "llcp.h"
+#include "PN532_debug.h"
+
+// LLCP PDU Type Values
+#define PDU_SYMM    0x00
+#define PDU_PAX     0x01
+#define PDU_CONNECT 0x04
+#define PDU_DISC    0x05
+#define PDU_CC      0x06
+#define PDU_DM      0x07
+#define PDU_I       0x0c
+#define PDU_RR      0x0d
+
+uint8_t LLCP::SYMM_PDU[2] = {0, 0};
+
+inline uint8_t getPType(const uint8_t *buf)
+{
+    return ((buf[0] & 0x3) << 2) + (buf[1] >> 6);
+}
+
+inline uint8_t getSSAP(const uint8_t *buf)
+{
+    return  buf[1] & 0x3f;
+}
+
+inline uint8_t getDSAP(const uint8_t *buf)
+{
+    return buf[0] >> 2;
+}
+
+int8_t LLCP::activate(uint16_t timeout)
+{
+    return link.activateAsTarget(timeout);
+}
+
+int8_t LLCP::waitForConnection(uint16_t timeout)
+{
+    uint8_t type;
+
+    mode = 1;
+    ns = 0;
+    nr = 0;
+
+    // Get CONNECT PDU
+    DMSG("wait for a CONNECT PDU\n");
+    do {
+        if (2 > link.read(headerBuf, headerBufLen)) {
+            return -1;
+        }
+
+        type = getPType(headerBuf);
+        if (PDU_CONNECT == type) {
+            break;
+        } else if (PDU_SYMM == type) {
+            if (!link.write(SYMM_PDU, sizeof(SYMM_PDU))) {
+                return -2;
+            }
+        } else {
+            return -3;
+        }
+
+    } while (1);
+
+    // Put CC PDU
+    DMSG("put a CC(Connection Complete) PDU to response the CONNECT PDU\n");
+    ssap = getDSAP(headerBuf);
+    dsap = getSSAP(headerBuf);
+    headerBuf[0] = (dsap << 2) + ((PDU_CC >> 2) & 0x3);
+    headerBuf[1] = ((PDU_CC & 0x3) << 6) + ssap;
+    if (!link.write(headerBuf, 2)) {
+        return -2;
+    }
+
+    return 1;
+}
+
+int8_t LLCP::waitForDisconnection(uint16_t timeout)
+{
+    uint8_t type;
+
+    // Get DISC PDU
+    DMSG("wait for a DISC PDU\n");
+    do {
+        if (2 > link.read(headerBuf, headerBufLen)) {
+            return -1;
+        }
+
+        type = getPType(headerBuf);
+        if (PDU_DISC == type) {
+            break;
+        } else if (PDU_SYMM == type) {
+            if (!link.write(SYMM_PDU, sizeof(SYMM_PDU))) {
+                return -2;
+            }
+        } else {
+            return -3;
+        }
+
+    } while (1);
+
+    // Put DM PDU
+    DMSG("put a DM(Disconnect Mode) PDU to response the DISC PDU\n");
+    // ssap = getDSAP(headerBuf);
+    // dsap = getSSAP(headerBuf);
+    headerBuf[0] = (dsap << 2) + (PDU_DM >> 2);
+    headerBuf[1] = ((PDU_DM & 0x3) << 6) + ssap;
+    if (!link.write(headerBuf, 2)) {
+        return -2;
+    }
+
+    return 1;
+}
+
+int8_t LLCP::connect(uint16_t timeout)
+{
+    uint8_t type;
+
+    mode = 0;
+    dsap = LLCP_DEFAULT_DSAP;
+    ssap = LLCP_DEFAULT_SSAP;
+    ns = 0;
+    nr = 0;
+
+    // try to get a SYMM PDU
+    if (2 > link.read(headerBuf, headerBufLen)) {
+        return -1;
+    }
+    type = getPType(headerBuf);
+    if (PDU_SYMM != type) {
+        return -1;
+    }
+
+    // put a CONNECT PDU
+    headerBuf[0] = (LLCP_DEFAULT_DSAP << 2) + (PDU_CONNECT >> 2);
+    headerBuf[1] = ((PDU_CONNECT & 0x03) << 6) + LLCP_DEFAULT_SSAP;
+    uint8_t body[] = "  urn:nfc:sn:snep";
+    body[0] = 0x06;
+    body[1] = sizeof(body) - 2 - 1;
+    if (!link.write(headerBuf, 2, body, sizeof(body) - 1)) {
+        return -2;
+    }
+
+    // wait for a CC PDU
+    DMSG("wait for a CC PDU\n");
+    do {
+        if (2 > link.read(headerBuf, headerBufLen)) {
+            return -1;
+        }
+
+        type = getPType(headerBuf);
+        if (PDU_CC == type) {
+            break;
+        } else if (PDU_SYMM == type) {
+            if (!link.write(SYMM_PDU, sizeof(SYMM_PDU))) {
+                return -2;
+            }
+        } else {
+            return -3;
+        }
+
+    } while (1);
+
+    return 1;
+}
+
+int8_t LLCP::disconnect(uint16_t timeout)
+{
+    uint8_t type;
+
+    // try to get a SYMM PDU
+    if (2 > link.read(headerBuf, headerBufLen)) {
+        return -1;
+    }
+    type = getPType(headerBuf);
+    if (PDU_SYMM != type) {
+        return -1;
+    }
+
+    // put a DISC PDU
+    headerBuf[0] = (LLCP_DEFAULT_DSAP << 2) + (PDU_DISC >> 2);
+    headerBuf[1] = ((PDU_DISC & 0x03) << 6) + LLCP_DEFAULT_SSAP;
+    if (!link.write(headerBuf, 2)) {
+        return -2;
+    }
+
+    // wait for a DM PDU
+    DMSG("wait for a DM PDU\n");
+    do {
+        if (2 > link.read(headerBuf, headerBufLen)) {
+            return -1;
+        }
+
+        type = getPType(headerBuf);
+        if (PDU_CC == type) {
+            break;
+        } else if (PDU_DM == type) {
+            if (!link.write(SYMM_PDU, sizeof(SYMM_PDU))) {
+                return -2;
+            }
+        } else {
+            return -3;
+        }
+
+    } while (1);
+
+    return 1;
+}
+
+bool LLCP::write(const uint8_t *header, uint8_t hlen, const uint8_t *body, uint8_t blen)
+{
+    uint8_t type;
+    uint8_t buf[3];
+
+    if (mode) {
+        // Get a SYMM PDU
+        if (2 != link.read(buf, sizeof(buf))) {
+            return false;
+        }
+    }
+
+    if (headerBufLen < (hlen + 3)) {
+        return false;
+    }
+
+    for (int8_t i = hlen - 1; i >= 0; i--) {
+        headerBuf[i + 3] = header[i];
+    }
+
+    headerBuf[0] = (dsap << 2) + (PDU_I >> 2);
+    headerBuf[1] = ((PDU_I & 0x3) << 6) + ssap;
+    headerBuf[2] = (ns << 4) + nr;
+    if (!link.write(headerBuf, 3 + hlen, body, blen)) {
+        return false;
+    }
+
+    ns++;
+
+    // Get a RR PDU
+    int16_t status;
+    do {
+        status = link.read(headerBuf, headerBufLen);
+        if (2 > status) {
+            return false;
+        }
+
+        type = getPType(headerBuf);
+        if (PDU_RR == type) {
+            break;
+        } else if (PDU_SYMM == type) {
+            if (!link.write(SYMM_PDU, sizeof(SYMM_PDU))) {
+                return false;
+            }
+        } else {
+            return false;
+        }
+    } while (1);
+
+    if (!link.write(SYMM_PDU, sizeof(SYMM_PDU))) {
+        return false;
+    }
+
+    return true;
+}
+
+int16_t LLCP::read(uint8_t *buf, uint8_t length)
+{
+    uint8_t type;
+    uint16_t status;
+
+    // Get INFO PDU
+    do {
+        status = link.read(buf, length);
+        if (2 > status) {
+            return -1;
+        }
+
+        type = getPType(buf);
+        if (PDU_I == type) {
+            break;
+        } else if (PDU_SYMM == type) {
+            if (!link.write(SYMM_PDU, sizeof(SYMM_PDU))) {
+                return -2;
+            }
+        } else {
+            return -3;
+        }
+
+    } while (1);
+
+    uint8_t len = status - 3;
+    ssap = getDSAP(buf);
+    dsap = getSSAP(buf);
+
+    headerBuf[0] = (dsap << 2) + (PDU_RR >> 2);
+    headerBuf[1] = ((PDU_RR & 0x3) << 6) + ssap;
+    headerBuf[2] = (buf[2] >> 4) + 1;
+    if (!link.write(headerBuf, 3)) {
+        return -2;
+    }
+
+    for (uint8_t i = 0; i < len; i++) {
+        buf[i] = buf[i + 3];
+    }
+
+    nr++;
+
+    return len;
+}
@@ -0,0 +1,75 @@
+
+#ifndef __LLCP_H__
+#define __LLCP_H__
+
+#include "mac_link.h"
+
+#define LLCP_DEFAULT_TIMEOUT  20000
+#define LLCP_DEFAULT_DSAP     0x04
+#define LLCP_DEFAULT_SSAP     0x20
+
+class LLCP {
+public:
+	LLCP(PN532Interface &interface) : link(interface) {
+        headerBuf = link.getHeaderBuffer(&headerBufLen);
+        ns = 0;
+        nr = 0;
+	};
+
+	/**
+    * @brief    Actiave PN532 as a target
+    * @param    timeout max time to wait, 0 means no timeout
+    * @return   > 0     success
+    *           = 0     timeout
+    *           < 0     failed
+    */
+	int8_t activate(uint16_t timeout = 0);
+
+    int8_t waitForConnection(uint16_t timeout = LLCP_DEFAULT_TIMEOUT);
+
+    int8_t waitForDisconnection(uint16_t timeout = LLCP_DEFAULT_TIMEOUT);
+
+    int8_t connect(uint16_t timeout = LLCP_DEFAULT_TIMEOUT);
+
+    int8_t disconnect(uint16_t timeout = LLCP_DEFAULT_TIMEOUT);
+
+	/**
+    * @brief    write a packet, the packet should be less than (255 - 2) bytes
+    * @param    header  packet header
+    * @param    hlen    length of header
+    * @param    body    packet body
+    * @param    blen    length of body
+    * @return   true    success
+    *           false   failed
+    */
+    bool write(const uint8_t *header, uint8_t hlen, const uint8_t *body = 0, uint8_t blen = 0);
+
+    /**
+    * @brief    read a  packet, the packet will be less than (255 - 2) bytes
+    * @param    buf     the buffer to contain the packet
+    * @param    len     lenght of the buffer
+    * @return   >=0     length of the packet 
+    *           <0      failed
+    */
+    int16_t read(uint8_t *buf, uint8_t len);
+
+    uint8_t *getHeaderBuffer(uint8_t *len) {
+        uint8_t *buf = link.getHeaderBuffer(len);
+        len -= 3;       // I PDU header has 3 bytes
+        return buf;
+    };
+
+private:
+	MACLink link;
+    uint8_t mode;
+	uint8_t ssap;
+	uint8_t dsap;
+    uint8_t *headerBuf;
+    uint8_t headerBufLen;
+    uint8_t ns;         // Number of I PDU Sent
+    uint8_t nr;         // Number of I PDU Received
+
+	static uint8_t SYMM_PDU[2];
+};
+
+#endif // __LLCP_H__
@@ -0,0 +1,20 @@
+
+#include "mac_link.h"
+#include "PN532_debug.h"
+
+int8_t MACLink::activateAsTarget(uint16_t timeout)
+{
+	pn532.begin();
+	pn532.SAMConfig();
+    return pn532.tgInitAsTarget(timeout);
+}
+
+bool MACLink::write(const uint8_t *header, uint8_t hlen, const uint8_t *body, uint8_t blen)
+{
+    return pn532.tgSetData(header, hlen, body, blen);
+}
+
+int16_t MACLink::read(uint8_t *buf, uint8_t len)
+{
+    return pn532.tgGetData(buf, len);
+}
@@ -0,0 +1,51 @@
+
+
+#ifndef __MAC_LINK_H__
+#define __MAC_LINK_H__
+
+#include "PN532.h"
+
+class MACLink {
+public:
+    MACLink(PN532Interface &interface) : pn532(interface) {
+
+    };
+    
+    /**
+    * @brief    Activate PN532 as a target
+    * @param    timeout max time to wait, 0 means no timeout
+    * @return   > 0     success
+    *           = 0     timeout
+    *           < 0     failed
+    */
+    int8_t activateAsTarget(uint16_t timeout = 0);
+
+    /**
+    * @brief    write a PDU packet, the packet should be less than (255 - 2) bytes
+    * @param    header  packet header
+    * @param    hlen    length of header
+    * @param 	body	packet body
+    * @param 	blen	length of body
+    * @return   true    success
+    *           false   failed
+    */
+    bool write(const uint8_t *header, uint8_t hlen, const uint8_t *body = 0, uint8_t blen = 0);
+
+    /**
+    * @brief    read a PDU packet, the packet will be less than (255 - 2) bytes
+    * @param    buf     the buffer to contain the PDU packet
+    * @param    len     lenght of the buffer
+    * @return   >=0     length of the PDU packet 
+    *           <0      failed
+    */
+    int16_t read(uint8_t *buf, uint8_t len);
+
+    uint8_t *getHeaderBuffer(uint8_t *len) {
+        return pn532.getBuffer(len);
+    };
+    
+private:
+    PN532 pn532;
+};
+
+#endif // __MAC_LINK_H__
@@ -0,0 +1,106 @@
+
+#include "snep.h"
+#include "PN532_debug.h"
+
+int8_t SNEP::write(const uint8_t *buf, uint8_t len, uint16_t timeout)
+{
+	if (0 >= llcp.activate(timeout)) {
+		DMSG("failed to activate PN532 as a target\n");
+		return -1;
+	}
+
+	if (0 >= llcp.connect(timeout)) {
+		DMSG("failed to set up a connection\n");
+		return -2;
+	}
+
+	// response a success SNEP message
+	headerBuf[0] = SNEP_DEFAULT_VERSION;
+	headerBuf[1] = SNEP_REQUEST_PUT;
+	headerBuf[2] = 0;
+	headerBuf[3] = 0;
+	headerBuf[4] = 0;
+	headerBuf[5] = len;
+	if (0 >= llcp.write(headerBuf, 6, buf, len)) {
+		return -3;
+	}
+
+	uint8_t rbuf[16];
+	if (6 > llcp.read(rbuf, sizeof(rbuf))) {
+		return -4;
+	}
+
+	// check SNEP version
+	if (SNEP_DEFAULT_VERSION != rbuf[0]) {
+		DMSG("The received SNEP message's major version is different\n");
+		// To-do: send Unsupported Version response
+		return -4;
+	}
+
+	// expect a put request
+	if (SNEP_RESPONSE_SUCCESS != rbuf[1]) {
+		DMSG("Expect a success response\n");
+		return -4;
+	}
+
+	llcp.disconnect(timeout);
+
+	return 1;
+}
+
+int16_t SNEP::read(uint8_t *buf, uint8_t len, uint16_t timeout)
+{
+	if (0 >= llcp.activate(timeout)) {
+		DMSG("failed to activate PN532 as a target\n");
+		return -1;
+	}
+
+	if (0 >= llcp.waitForConnection(timeout)) {
+		DMSG("failed to set up a connection\n");
+		return -2;
+	}
+
+	uint16_t status = llcp.read(buf, len);
+	if (6 > status) {
+		return -3;
+	}
+
+
+	// check SNEP version
+	if (SNEP_DEFAULT_VERSION != buf[0]) {
+		DMSG("The received SNEP message's major version is different\n");
+		// To-do: send Unsupported Version response
+		return -4;
+	}
+
+	// expect a put request
+	if (SNEP_REQUEST_PUT != buf[1]) {
+		DMSG("Expect a put request\n");
+		return -4;
+	}
+
+	// check message's length
+	uint32_t length = (buf[2] << 24) + (buf[3] << 16) + (buf[4] << 8) + buf[5];
+	// length should not be more than 244 (header + body < 255, header = 6 + 3 + 2)
+	if (length > (status - 6)) {
+		DMSG("The SNEP message is too large: "); 
+        DMSG_INT(length);
+        DMSG_INT(status - 6);
+		DMSG("\n");
+		return -4;
+	}
+	for (uint8_t i = 0; i < length; i++) {
+		buf[i] = buf[i + 6];
+	}
+
+	// response a success SNEP message
+	headerBuf[0] = SNEP_DEFAULT_VERSION;
+	headerBuf[1] = SNEP_RESPONSE_SUCCESS;
+	headerBuf[2] = 0;
+	headerBuf[3] = 0;
+	headerBuf[4] = 0;
+	headerBuf[5] = 0;
+	llcp.write(headerBuf, 6);
+
+	return length;
+}
@@ -0,0 +1,49 @@
+
+
+#ifndef __SNEP_H__
+#define __SNEP_H__
+
+#include "llcp.h"
+
+#define SNEP_DEFAULT_VERSION	0x10	// Major: 1, Minor: 0
+
+#define SNEP_REQUEST_PUT		0x02
+#define SNEP_REQUEST_GET		0x01
+
+#define SNEP_RESPONSE_SUCCESS	0x81
+#define SNEP_RESPONSE_REJECT	0xFF
+
+class SNEP {
+public:
+	SNEP(PN532Interface &interface) : llcp(interface) {
+		headerBuf = llcp.getHeaderBuffer(&headerBufLen);
+	};
+
+	/**
+    * @brief    write a SNEP packet, the packet should be less than (255 - 2 - 3) bytes
+    * @param    buf     the buffer to contain the packet
+    * @param    len     lenght of the buffer
+    * @param    timeout max time to wait, 0 means no timeout
+    * @return   >0      success
+    *			=0      timeout
+    *           <0      failed
+    */
+    int8_t write(const uint8_t *buf, uint8_t len, uint16_t timeout = 0);
+
+    /**
+    * @brief    read a SNEP packet, the packet will be less than (255 - 2 - 3) bytes
+    * @param    buf     the buffer to contain the packet
+    * @param    len     lenght of the buffer
+    * @param    timeout max time to wait, 0 means no timeout
+    * @return   >=0     length of the packet 
+    *           <0      failed
+    */
+    int16_t read(uint8_t *buf, uint8_t len, uint16_t timeout = 0);
+
+private:
+	LLCP llcp;
+	uint8_t *headerBuf;
+	uint8_t headerBufLen;
+};
+
+#endif // __SNEP_H__
@@ -0,0 +1,196 @@
+
+#include "PN532_HSU.h"
+#include "PN532_debug.h"
+
+
+PN532_HSU::PN532_HSU(HardwareSerial &serial)
+{
+    _serial = &serial;
+    command = 0;
+}
+
+void PN532_HSU::begin()
+{
+    _serial->begin(115200);
+}
+
+void PN532_HSU::wakeup()
+{
+    _serial->write(0x55);
+    _serial->write(0x55);
+    _serial->write(0);
+    _serial->write(0);
+    _serial->write(0);
+
+    /** dump serial buffer */
+    if(_serial->available()){
+        DMSG("Dump serial buffer: ");
+    }
+    while(_serial->available()){
+        uint8_t ret = _serial->read();
+        DMSG_HEX(ret);
+    }
+
+}
+
+int8_t PN532_HSU::writeCommand(const uint8_t *header, uint8_t hlen, const uint8_t *body, uint8_t blen)
+{
+
+    /** dump serial buffer */
+    if(_serial->available()){
+        DMSG("Dump serial buffer: ");
+    }
+    while(_serial->available()){
+        uint8_t ret = _serial->read();
+        DMSG_HEX(ret);
+    }
+
+    command = header[0];
+    
+    _serial->write(PN532_PREAMBLE);
+    _serial->write(PN532_STARTCODE1);
+    _serial->write(PN532_STARTCODE2);
+    
+    uint8_t length = hlen + blen + 1;   // length of data field: TFI + DATA
+    _serial->write(length);
+    _serial->write(~length + 1);         // checksum of length
+    
+    _serial->write(PN532_HOSTTOPN532);
+    uint8_t sum = PN532_HOSTTOPN532;    // sum of TFI + DATA
+
+    DMSG("\nWrite: ");
+    
+    _serial->write(header, hlen);
+    for (uint8_t i = 0; i < hlen; i++) {
+        sum += header[i];
+
+        DMSG_HEX(header[i]);
+    }
+
+    _serial->write(body, blen);
+    for (uint8_t i = 0; i < blen; i++) {
+        sum += body[i];
+
+        DMSG_HEX(body[i]);
+    }
+    
+    uint8_t checksum = ~sum + 1;            // checksum of TFI + DATA
+    _serial->write(checksum);
+    _serial->write(PN532_POSTAMBLE);
+
+    return readAckFrame();
+}
+
+int16_t PN532_HSU::readResponse(uint8_t buf[], uint8_t len, uint16_t timeout)
+{
+    uint8_t tmp[3];
+    
+    DMSG("\nRead:  ");
+    
+    /** Frame Preamble and Start Code */
+    if(receive(tmp, 3, timeout)<=0){
+        return PN532_TIMEOUT;
+    }
+    if(0 != tmp[0] || 0!= tmp[1] || 0xFF != tmp[2]){
+        DMSG("Preamble error");
+        return PN532_INVALID_FRAME;
+    }
+    
+    /** receive length and check */
+    uint8_t length[2];
+    if(receive(length, 2, timeout) <= 0){
+        return PN532_TIMEOUT;
+    }
+    if( 0 != (uint8_t)(length[0] + length[1]) ){
+        DMSG("Length error");
+        return PN532_INVALID_FRAME;
+    }
+    length[0] -= 2;
+    if( length[0] > len){
+        return PN532_NO_SPACE;
+    }
+    
+    /** receive command byte */
+    uint8_t cmd = command + 1;               // response command
+    if(receive(tmp, 2, timeout) <= 0){
+        return PN532_TIMEOUT;
+    }
+    if( PN532_PN532TOHOST != tmp[0] || cmd != tmp[1]){
+        DMSG("Command error");
+        return PN532_INVALID_FRAME;
+    }
+    
+    if(receive(buf, length[0], timeout) != length[0]){
+        return PN532_TIMEOUT;
+    }
+    uint8_t sum = PN532_PN532TOHOST + cmd;
+    for(uint8_t i=0; i<length[0]; i++){
+        sum += buf[i];
+    }
+    
+    /** checksum and postamble */
+    if(receive(tmp, 2, timeout) <= 0){
+        return PN532_TIMEOUT;
+    }
+    if( 0 != (uint8_t)(sum + tmp[0]) || 0 != tmp[1] ){
+        DMSG("Checksum error");
+        return PN532_INVALID_FRAME;
+    }
+    
+    return length[0];
+}
+
+int8_t PN532_HSU::readAckFrame()
+{
+    const uint8_t PN532_ACK[] = {0, 0, 0xFF, 0, 0xFF, 0};
+    uint8_t ackBuf[sizeof(PN532_ACK)];
+    
+    DMSG("\nAck: ");
+    
+    if( receive(ackBuf, sizeof(PN532_ACK), PN532_ACK_WAIT_TIME) <= 0 ){
+        DMSG("Timeout\n");
+        return PN532_TIMEOUT;
+    }
+    
+    if( memcmp(ackBuf, PN532_ACK, sizeof(PN532_ACK)) ){
+        DMSG("Invalid\n");
+        return PN532_INVALID_ACK;
+    }
+    return 0;
+}
+
+/**
+    @brief receive data .
+    @param buf --> return value buffer.
+           len --> length expect to receive.
+           timeout --> time of reveiving
+    @retval number of received bytes, 0 means no data received.
+*/
+int8_t PN532_HSU::receive(uint8_t *buf, int len, uint16_t timeout)
+{
+  int read_bytes = 0;
+  int ret;
+  unsigned long start_millis;
+  
+  while (read_bytes < len) {
+    start_millis = millis();
+    do {
+      ret = _serial->read();
+      if (ret >= 0) {
+        break;
+     }
+    } while((timeout == 0) || ((millis()- start_millis ) < timeout));
+    
+    if (ret < 0) {
+        if(read_bytes){
+            return read_bytes;
+        }else{
+            return PN532_TIMEOUT;
+        }
+    }
+    buf[read_bytes] = (uint8_t)ret;
+    DMSG_HEX(ret);
+    read_bytes++;
+  }
+  return read_bytes;
+}
@@ -0,0 +1,30 @@
+
+#ifndef __PN532_HSU_H__
+#define __PN532_HSU_H__
+
+#include "PN532Interface.h"
+#include "Arduino.h"
+
+#define PN532_HSU_DEBUG
+
+#define PN532_HSU_READ_TIMEOUT						(1000)
+
+class PN532_HSU : public PN532Interface {
+public:
+    PN532_HSU(HardwareSerial &serial);
+    
+    void begin();
+    void wakeup();
+    virtual int8_t writeCommand(const uint8_t *header, uint8_t hlen, const uint8_t *body = 0, uint8_t blen = 0);
+    int16_t readResponse(uint8_t buf[], uint8_t len, uint16_t timeout);
+    
+private:
+    HardwareSerial* _serial;
+    uint8_t command;
+    
+    int8_t readAckFrame();
+    
+    int8_t receive(uint8_t *buf, int len, uint16_t timeout=PN532_HSU_READ_TIMEOUT);
+};
+
+#endif
@@ -0,0 +1,181 @@
+
+#include "PN532_I2C.h"
+#include "PN532_debug.h"
+#include "Arduino.h"
+
+#define PN532_I2C_ADDRESS       (0x48 >> 1)
+
+
+PN532_I2C::PN532_I2C(TwoWire &wire)
+{
+    _wire = &wire;
+    command = 0;
+}
+
+void PN532_I2C::begin()
+{
+    _wire->begin();
+}
+
+void PN532_I2C::wakeup()
+{
+    _wire->beginTransmission(PN532_I2C_ADDRESS); // I2C start
+    delay(20);
+    _wire->endTransmission();                    // I2C end
+}
+
+int8_t PN532_I2C::writeCommand(const uint8_t *header, uint8_t hlen, const uint8_t *body, uint8_t blen)
+{
+    command = header[0];
+    _wire->beginTransmission(PN532_I2C_ADDRESS);
+    
+    write(PN532_PREAMBLE);
+    write(PN532_STARTCODE1);
+    write(PN532_STARTCODE2);
+    
+    uint8_t length = hlen + blen + 1;   // length of data field: TFI + DATA
+    write(length);
+    write(~length + 1);                 // checksum of length
+    
+    write(PN532_HOSTTOPN532);
+    uint8_t sum = PN532_HOSTTOPN532;    // sum of TFI + DATA
+    
+    DMSG("write: ");
+       
+    for (uint8_t i = 0; i < hlen; i++) {
+        if (write(header[i])) {
+            sum += header[i];
+            
+            DMSG_HEX(header[i]);
+        } else {
+            DMSG("\nToo many data to send, I2C doesn't support such a big packet\n");     // I2C max packet: 32 bytes
+            return PN532_INVALID_FRAME;
+        }
+    }
+
+    for (uint8_t i = 0; i < blen; i++) {
+        if (write(body[i])) {
+            sum += body[i];
+            
+            DMSG_HEX(body[i]);
+        } else {
+            DMSG("\nToo many data to send, I2C doesn't support such a big packet\n");     // I2C max packet: 32 bytes
+            return PN532_INVALID_FRAME;
+        }
+    }
+  
+    uint8_t checksum = ~sum + 1;            // checksum of TFI + DATA
+    write(checksum);
+    write(PN532_POSTAMBLE);
+    
+    _wire->endTransmission();
+    
+    DMSG('\n');
+
+    return readAckFrame();
+}
+
+int16_t PN532_I2C::readResponse(uint8_t buf[], uint8_t len, uint16_t timeout)
+{
+    uint16_t time = 0;
+
+    do {
+        if (_wire->requestFrom(PN532_I2C_ADDRESS, len + 2)) {
+            if (read() & 1) {  // check first byte --- status
+                break;         // PN532 is ready
+            }
+        }
+
+        delay(1);
+        time++;
+        if ((0 != timeout) && (time > timeout)) {
+            return -1;
+        }
+    } while (1); 
+    
+    if (0x00 != read()      ||       // PREAMBLE
+            0x00 != read()  ||       // STARTCODE1
+            0xFF != read()           // STARTCODE2
+        ) {
+        
+        return PN532_INVALID_FRAME;
+    }
+    
+    uint8_t length = read();
+    if (0 != (uint8_t)(length + read())) {   // checksum of length
+        return PN532_INVALID_FRAME;
+    }
+    
+    uint8_t cmd = command + 1;               // response command
+    if (PN532_PN532TOHOST != read() || (cmd) != read()) {
+        return PN532_INVALID_FRAME;
+    }
+    
+    length -= 2;
+    if (length > len) {
+        return PN532_NO_SPACE;  // not enough space
+    }
+    
+    DMSG("read:  ");
+    DMSG_HEX(cmd);
+    
+    uint8_t sum = PN532_PN532TOHOST + cmd;
+    for (uint8_t i = 0; i < length; i++) {
+        buf[i] = read();
+        sum += buf[i];
+        
+        DMSG_HEX(buf[i]);
+    }
+    DMSG('\n');
+    
+    uint8_t checksum = read();
+    if (0 != (uint8_t)(sum + checksum)) {
+        DMSG("checksum is not ok\n");
+        return PN532_INVALID_FRAME;
+    }
+    read();         // POSTAMBLE
+    
+    return length;
+}
+
+int8_t PN532_I2C::readAckFrame()
+{
+    const uint8_t PN532_ACK[] = {0, 0, 0xFF, 0, 0xFF, 0};
+    uint8_t ackBuf[sizeof(PN532_ACK)];
+    
+    DMSG("wait for ack at : ");
+    DMSG(millis());
+    DMSG('\n');
+    
+    uint16_t time = 0;
+    do {
+        if (_wire->requestFrom(PN532_I2C_ADDRESS,  sizeof(PN532_ACK) + 1)) {
+            if (read() & 1) {  // check first byte --- status
+                break;         // PN532 is ready
+            }
+        }
+
+        delay(1);
+        time++;
+        if (time > PN532_ACK_WAIT_TIME) {
+            DMSG("Time out when waiting for ACK\n");
+            return PN532_TIMEOUT;
+        }
+    } while (1); 
+    
+    DMSG("ready at : ");
+    DMSG(millis());
+    DMSG('\n');
+    
+
+    for (uint8_t i = 0; i < sizeof(PN532_ACK); i++) {
+        ackBuf[i] = read();
+    }
+    
+    if (memcmp(ackBuf, PN532_ACK, sizeof(PN532_ACK))) {
+        DMSG("Invalid ACK\n");
+        return PN532_INVALID_ACK;
+    }
+    
+    return 0;
+}
@@ -0,0 +1,40 @@
+
+#ifndef __PN532_I2C_H__
+#define __PN532_I2C_H__
+
+#include <Wire.h>
+#include "PN532Interface.h"
+
+class PN532_I2C : public PN532Interface {
+public:
+    PN532_I2C(TwoWire &wire);
+    
+    void begin();
+    void wakeup();
+    virtual int8_t writeCommand(const uint8_t *header, uint8_t hlen, const uint8_t *body = 0, uint8_t blen = 0);
+    int16_t readResponse(uint8_t buf[], uint8_t len, uint16_t timeout);
+    
+private:
+    TwoWire* _wire;
+    uint8_t command;
+    
+    int8_t readAckFrame();
+    
+    inline uint8_t write(uint8_t data) {
+        #if ARDUINO >= 100
+            return _wire->write(data);
+        #else
+            return _wire->send(data);
+        #endif
+    }
+    
+    inline uint8_t read() {
+        #if ARDUINO >= 100
+            return _wire->read();
+        #else
+            return _wire->receive();
+        #endif
+    }
+};
+
+#endif
@@ -0,0 +1,217 @@
+#include <util/delay.h>
+#include "PN532_SPI.h"
+#include "PN532_debug.h"
+#include "Arduino.h"
+
+#define STATUS_READ     2
+#define DATA_WRITE      1
+#define DATA_READ       3
+#define	delay(a)		_delay_ms(a)
+
+void send_serial(unsigned char);
+
+PN532_SPI::PN532_SPI(SPIClass &spi, uint8_t ss)
+{
+    command = 0;
+    _spi = &spi;
+    _ss  = ss;
+}
+
+void PN532_SPI::begin()
+{
+    pinMode(_ss, OUTPUT);
+
+    _spi->begin();
+    _spi->setDataMode(SPI_MODE0);  // PN532 only supports mode0
+    _spi->setBitOrder(LSBFIRST);
+#ifndef __SAM3X8E__
+    _spi->setClockDivider(SPI_CLOCK_DIV8); // set clock 2MHz(max: 5MHz)
+#else 
+    /** DUE spi library does not support SPI_CLOCK_DIV8 macro */
+    _spi->setClockDivider(42);             // set clock 2MHz(max: 5MHz)
+#endif
+
+}
+
+void PN532_SPI::wakeup()
+{
+	send_serial('Z');
+    digitalWrite(_ss, LOW);
+	send_serial('E');
+    delay(2);
+	send_serial('R');
+    digitalWrite(_ss, HIGH);
+	send_serial('T');
+}
+
+
+
+int8_t PN532_SPI::writeCommand(const uint8_t *header, uint8_t hlen, const uint8_t *body, uint8_t blen)
+{
+    command = header[0];
+    writeFrame(header, hlen, body, blen);
+    
+    uint8_t timeout = PN532_ACK_WAIT_TIME;
+    while (!isReady()) {
+        delay(1);
+        timeout--;
+        if (0 == timeout) {
+            DMSG("Time out when waiting for ACK\n");
+            return -2;
+        }
+    }
+    if (readAckFrame()) {
+        DMSG("Invalid ACK\n");
+        return PN532_INVALID_ACK;
+    }
+    return 0;
+}
+
+int16_t PN532_SPI::readResponse(uint8_t buf[], uint8_t len, uint16_t timeout)
+{
+    uint16_t time = 0;
+    while (!isReady()) {
+        delay(1);
+        time++;
+        if (timeout > 0 && time > timeout) {
+            return PN532_TIMEOUT;
+        }
+    }
+
+    digitalWrite(_ss, LOW);
+    delay(1);
+
+    int16_t result;
+    do {
+        write(DATA_READ);
+
+        if (0x00 != read()      ||       // PREAMBLE
+                0x00 != read()  ||       // STARTCODE1
+                0xFF != read()           // STARTCODE2
+           ) {
+
+            result = PN532_INVALID_FRAME;
+            break;
+        }
+
+        uint8_t length = read();
+        if (0 != (uint8_t)(length + read())) {   // checksum of length
+            result = PN532_INVALID_FRAME;
+            break;
+        }
+
+        uint8_t cmd = command + 1;               // response command
+        if (PN532_PN532TOHOST != read() || (cmd) != read()) {
+            result = PN532_INVALID_FRAME;
+            break;
+        }
+
+        DMSG("read:  ");
+        DMSG_HEX(cmd);
+
+        length -= 2;
+        if (length > len) {
+            for (uint8_t i = 0; i < length; i++) {
+                DMSG_HEX(read());                 // dump message
+            }
+            DMSG("\nNot enough space\n");
+            read();
+            read();
+            result = PN532_NO_SPACE;  // not enough space
+            break;
+        }
+
+        uint8_t sum = PN532_PN532TOHOST + cmd;
+        for (uint8_t i = 0; i < length; i++) {
+            buf[i] = read();
+            sum += buf[i];
+
+            DMSG_HEX(buf[i]);
+        }
+        DMSG('\n');
+
+        uint8_t checksum = read();
+        if (0 != (uint8_t)(sum + checksum)) {
+            DMSG("checksum is not ok\n");
+            result = PN532_INVALID_FRAME;
+            break;
+        }
+        read();         // POSTAMBLE
+
+        result = length;
+    } while (0);
+
+    digitalWrite(_ss, HIGH);
+
+    return result;
+}
+
+boolean PN532_SPI::isReady()
+{
+    digitalWrite(_ss, LOW);
+
+    write(STATUS_READ);
+    uint8_t status = read() & 1;
+    digitalWrite(_ss, HIGH);
+    return status;
+}
+
+void PN532_SPI::writeFrame(const uint8_t *header, uint8_t hlen, const uint8_t *body, uint8_t blen)
+{
+    digitalWrite(_ss, LOW);
+    delay(2);               // wake up PN532
+
+    write(DATA_WRITE);
+    write(PN532_PREAMBLE);
+    write(PN532_STARTCODE1);
+    write(PN532_STARTCODE2);
+
+    uint8_t length = hlen + blen + 1;   // length of data field: TFI + DATA
+    write(length);
+    write(~length + 1);         // checksum of length
+
+    write(PN532_HOSTTOPN532);
+    uint8_t sum = PN532_HOSTTOPN532;    // sum of TFI + DATA
+
+    DMSG("write: ");
+
+    for (uint8_t i = 0; i < hlen; i++) {
+        write(header[i]);
+        sum += header[i];
+
+        DMSG_HEX(header[i]);
+    }
+    for (uint8_t i = 0; i < blen; i++) {
+        write(body[i]);
+        sum += body[i];
+
+        DMSG_HEX(body[i]);
+    }
+
+    uint8_t checksum = ~sum + 1;        // checksum of TFI + DATA
+    write(checksum);
+    write(PN532_POSTAMBLE);
+
+    digitalWrite(_ss, HIGH);
+
+    DMSG('\n');
+}
+
+int8_t PN532_SPI::readAckFrame()
+{
+    const uint8_t PN532_ACK[] = {0, 0, 0xFF, 0, 0xFF, 0};
+
+    uint8_t ackBuf[sizeof(PN532_ACK)];
+
+    digitalWrite(_ss, LOW);
+    delay(1);
+    write(DATA_READ);
+
+    for (uint8_t i = 0; i < sizeof(PN532_ACK); i++) {
+        ackBuf[i] = read();
+    }
+
+    digitalWrite(_ss, HIGH);
+
+    return memcmp(ackBuf, PN532_ACK, sizeof(PN532_ACK));
+}
@@ -0,0 +1,36 @@
+
+#ifndef __PN532_SPI_H__
+#define __PN532_SPI_H__
+
+#include <SPI.h>
+#include "PN532Interface.h"
+
+class PN532_SPI : public PN532Interface {
+public:
+    PN532_SPI(SPIClass &spi, uint8_t ss);
+    
+    void begin();
+    void wakeup();
+    int8_t writeCommand(const uint8_t *header, uint8_t hlen, const uint8_t *body = 0, uint8_t blen = 0);
+
+    int16_t readResponse(uint8_t buf[], uint8_t len, uint16_t timeout);
+    
+private:
+    SPIClass* _spi;
+    uint8_t   _ss;
+    uint8_t command;
+    
+    boolean isReady();
+    void writeFrame(const uint8_t *header, uint8_t hlen, const uint8_t *body = 0, uint8_t blen = 0);
+    int8_t readAckFrame();
+    
+    inline void write(uint8_t data) {
+        _spi->transfer(data);
+    };
+
+    inline uint8_t read() {
+        return _spi->transfer(0);
+    }; 
+};
+
+#endif
-#include <SPI.h>
-#include <PN532_SPI.h>
+#include <util/delay.h>
+#include <avr/io.h>
 #include "PN532.h"
+#include <PN532_SPI/PN532_SPI.h>
  
 #define	MODEL_QUERY			0x80
 #define	SERIAL_ERROR		0x55
@@ -8,9 +9,9 @@
 #define	NFC_TAGQUERY_UID	0x84
 #define	NFC_ARDUINO			0x02
 #define	NFC_NOTAG			0x81
-
-#define	NFC_TYPE_PROFESSOR	0x00
+#define	NFC_TYPE_PROFESSOR	0x04
 #define	NFC_TYPE_STUDENT	0x01
+#define	CPU_FREQ			16000000L
  
 boolean	tagDetected;
 boolean	tagType;
@@ -18,33 +19,56 @@ boolean	tagType;
 PN532_SPI pn532spi(SPI, 10);
 PN532 nfc(pn532spi);
  
+void init_serial(int speed)
+{
+	UBRR0 = CPU_FREQ/(((unsigned long int)speed)<<4)-1;
+	UCSR0B = (1<<TXEN0 | 1<<RXEN0);
+	UCSR0C = (1<<UCSZ01 | 1<<UCSZ00);
+	UCSR0A &= ~(1 << U2X0);
+}
+
+void send_serial(unsigned char c)
+{
+	loop_until_bit_is_set(UCSR0A, UDRE0);
+	UDR0 = c;
+}
+
+unsigned char get_serial(void)
+{
+	loop_until_bit_is_set(UCSR0A, RXC0);
+	return UDR0;
+}
+
+
 void setup(void)
 {
 	int ser;
  
-	Serial.begin(115200);
+	init_serial(9600);
  
+	send_serial('1');
 	nfc.begin();
  
+	send_serial('2');
 	uint32_t versiondata = nfc.getFirmwareVersion();
 	if(!versiondata)
 	{
-		Serial.print(SERIAL_ERROR);
+		send_serial(SERIAL_ERROR);
 		while (1);
 	}  
  
+	send_serial('3');
 	nfc.SAMConfig();
  
 	tagDetected = false;
  
 	do
 	{
-		while(!(Serial.available() > 0));
-		ser = Serial.read();
+		ser = get_serial();
 		if(ser == MODEL_QUERY)
-			Serial.print(NFC_ARDUINO);
+			send_serial(NFC_ARDUINO);
 		else
-			Serial.print(SERIAL_ERROR);
+			send_serial(SERIAL_ERROR);
 	}while(ser != MODEL_QUERY);
 }
  
@@ -56,7 +80,8 @@ void loop(void)
 	uint8_t uidLength;
 	uint8_t data1[16];
 	uint8_t data2[16];
-	uint8_t dataf[8];
+        char  professorTag[7];
+        char  studentTag[9];
 	int ser;
  
 	success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength);
@@ -87,24 +112,24 @@ void loop(void)
 						data1[9] == data2[4])
 						{
 							tagType = NFC_TYPE_PROFESSOR;
-							dataf[0] = data1[4];
-							dataf[1] = data1[5];
-							dataf[2] = data1[6];
-							dataf[3] = data1[7];
-							dataf[4] = data1[8];
-							dataf[5] = data1[9];
+							professorTag[0] = (char) 48 + data1[4];
+							professorTag[1] = (char) 48 + data1[5];
+							professorTag[2] = (char) 48 + data1[6];
+							professorTag[3] = (char) 48 + data1[7];
+							professorTag[4] = (char) 48 + data1[8];
+							professorTag[5] = (char) 48 + data1[9];
 						}
 						else
 						{
 							tagType = NFC_TYPE_STUDENT;
-							dataf[0] = data1[15];
-							dataf[1] = data2[0];
-							dataf[2] = data2[1];
-							dataf[3] = data2[2];
-							dataf[4] = data2[3];
-							dataf[5] = data2[4];
-							dataf[6] = data2[5];
-							dataf[7] = data2[6];
+							studentTag[0] = (char) 48 + data1[15];
+							studentTag[1] = (char) 48 + data2[0];
+							studentTag[2] = (char) 48 + data2[1];
+							studentTag[3] = (char) 48 + data2[2];
+							studentTag[4] = (char) 48 + data2[3];
+							studentTag[5] = (char) 48 + data2[4];
+							studentTag[6] = (char) 48 + data2[5];
+							studentTag[7] = (char) 48 + data2[6];
 						}
 					}
 				}
@@ -113,32 +138,53 @@ void loop(void)
 	}
 	else if(tagDetected)
 	{
-		while(!(Serial.available() > 0));
-		ser = Serial.read();
+		ser = get_serial();
 		if(ser == NFC_TAGQUERY)
-			Serial.print(tagType);
+			send_serial(tagType);
 		else if(ser == NFC_TAGQUERY_UID)
 		{
-			Serial.print((char) dataf[0]);
-			Serial.print((char) dataf[1]);
-			Serial.print((char) dataf[2]);
-			Serial.print((char) dataf[3]);
-			Serial.print((char) dataf[4]);
-			Serial.print((char) dataf[5]);
-			if(tagType == NFC_TYPE_STUDENT)
-			{
-				Serial.print((char) dataf[6]);
-				Serial.print((char) dataf[7]);
-			}
-			tagDetected = false;
+                    if(tagType == NFC_TYPE_STUDENT)
+                    {/*
+                        Serial.print((char) studentTag[0]);
+						Serial.print((char) studentTag[1]);
+                        Serial.print((char) studentTag[2]);
+						Serial.print((char) studentTag[3]);
+                        Serial.print((char) studentTag[4]);
+						Serial.print((char) studentTag[5]);
+                        Serial.print((char) studentTag[6]);
+						Serial.print((char) studentTag[7]);*/
+                        send_serial(0x10);
+						send_serial(0x20);
+                        send_serial(0x30);
+						send_serial(0x40);
+                        send_serial(0x50);
+						send_serial(0x60);
+	                    send_serial(0x70);
+						send_serial(0x80);
+                    }
+                    else
+                    {
+                        send_serial(professorTag[0]);
+                    }
+		    tagDetected = false;
 		}
 		else
-			Serial.print(SERIAL_ERROR);
+			send_serial((char) SERIAL_ERROR);
 	}
 	else
 	{
-		if(Serial.available() > 0)
-			if(Serial.read() == NFC_TAGQUERY)
-				Serial.print(NFC_NOTAG);
+		if(get_serial() == NFC_TAGQUERY)
+			send_serial(NFC_NOTAG);
 	}
 }
+
+int main(void)
+{
+	setup();
+
+	while(1)
+		send_serial('Y');
+		//loop();
+
+	return 0;
+}