NFC Arduino

In questi giorni ho fatto il mio primo test con l’NFC arduino usando una shield della DF Robot ed un arduino MEGA 2560

NFC Arduino

come ogni primo test delle nuove schede ho cercato e trovato la documentazione della shield per studiare come deve essere collegata ed avere un primo esempio di sketch da utlizzare.

Ho trovato la consueta wiki realizzata dal produttore della shield.

La scelta per realizzare il test dell’NFC arduino è caduta sull’arduinio MEGA 2560 in quanto dotata di quattro porte seriali:

arduino MEGA 2560 serial

anche se per il test ne userai soltanto 2:

  • la Serial: per comunicare con il monitor seriale
  • la Serial1: per comunicare con l’NFC arduino shield.

Il collegamento dell’NFC arduino

Il collegamento dell’NFC arduino è abbastanza semplice, basta seguire la wiki o semplicemnete conoscere come funziona la comunicazione seriale tra dispositivi.

Nell’esempio collega il TXD del dispositivo al pin Rx di arduino ed il contatto RXD del dispositivo al pin Tx di arduino.

In pratica ti troverai i collegamenti lato arduino:

NFC Arduino collegamenti mega

ed i collegamenti lato NFC arduino shield invertiti:

NFC Arduino collehamenti nfc

da cui puoi notare che il filo verde trasmette l’impulso seriale dall’NFC ad arduino ed il filo blu fa l’opposto.

Inoltre puoi notare che ho alimentato l’NFC a 3,3v anche se il dispositivo nfc è dotato di un circuito di alimentazione che accetta sia i 3,3v sia i 5v.

Lo sketch

Lo sketch di test dell’nfc arduino è quello fornito dal produttore della shield e copiato dalla wiki ufficiale.

Lo scopo dello sketch è inizializzare l’nfc arduino shield e leggere i tag nfc mostrando sul monitor seriale il valore del tag letto.

/*
 
 # Editor : Adrian
 # Date   : 2013.04.18
 # Ver    : 0.1
 # Product: NFC Module for Arduino
 # SKU    : DFR0231
    
 # Description:    
 # When the a card close to the device , the PC will receive the data
 # Connect the NFC Card's TXD, RXD, GND, +3.3V to Nano's D0RX, D1TX, GND, +3.3V
 # Or connect the NFC Card's TXD, RXD, GND, +5V to Nano's D0RX, D1TX, GND, +5V
 
  
 PN532 reads the tag by Arduino mega/Leonardo
 command list:
  
 #wake up reader
 send: 55 55 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ff 03 fd d4 14 01 17 00
 return: 00 00 FF 00 FF 00 00 00 FF 02 FE D5 15 16 00
  
 #get firmware
 send: 00 00 FF 02 FE D4 02 2A 00
 return: 00 00 FF 00 FF 00 00 00 FF 06 FA D5 03 32 01 06 07 E8 00
  
 #read the tag
 send: 00 00 FF 04 FC D4 4A 01 00 E1 00
 return: 00 00 FF 00 FF 00 00 00 FF 0C F4 D5 4B 01 01 00 04 08 04 XX XX XX XX 5A 00
 XX is tag.
  
 */
  
 //************* start **************
 
const unsigned char wake[24]={
  0x55, 0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03, 0xfd, 0xd4, 0x14, 0x01, 0x17, 0x00};//wake up NFC module
const unsigned char firmware[9]={
  0x00, 0x00, 0xFF, 0x02, 0xFE, 0xD4, 0x02, 0x2A, 0x00};//
const unsigned char tag[11]={
  0x00, 0x00, 0xFF, 0x04, 0xFC, 0xD4, 0x4A, 0x01, 0x00, 0xE1, 0x00};//detecting tag command
const unsigned char std_ACK[25] = {
  0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0x0C, \
0xF4, 0xD5, 0x4B, 0x01, 0x01, 0x00, 0x04, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x4b, 0x00};
unsigned char old_id[5];
 
unsigned char receive_ACK[25];//Command receiving buffer
//int inByte = 0;               //incoming serial byte buffer
 
#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#define print1Byte(args) Serial1.write(args)
#define print1lnByte(args)  Serial1.write(args),Serial1.println()
#else
#include "WProgram.h"
#define print1Byte(args) Serial1.print(args,BYTE)
#define print1lnByte(args)  Serial1.println(args,BYTE)
#endif
 
void setup()
{
  Serial.begin(9600);   // open serial with PC
  Serial1.begin(115200);    //open serial1 with device
  //Serial2.begin(115200);
  wake_card();
  delay(100);
  read_ACK(15);
  delay(100);
  display(15);
 
 
}
 
void loop()
{
  send_tag();
  read_ACK(25);
  delay(100);
  if (!cmp_id ()) {
    if (test_ACK ()) {
      display (25);
      delay (100);
    }
  }
  copy_id ();
}
 
 
void copy_id (void)
{//save old id
  int ai, oi;
  for (oi=0, ai=19; oi<5; oi++,ai++) {
    old_id[oi] = receive_ACK[ai];
  }
}
 
  
char cmp_id (void)
{//return true if find id is old
  int ai, oi;
  for (oi=0,ai=19; oi<5; oi++,ai++) {
    if (old_id[oi] != receive_ACK[ai])
      return 0;
  }
  return 1;
}
 
 
int test_ACK (void)
{// return true if receive_ACK accord with std_ACK
  int i;
  for (i=0; i<19; i++) {
    if (receive_ACK[i] != std_ACK[i])
      return 0;
  }
  return 1;
}
 
 
void send_id (void)
{//send id to PC
  int i;
  Serial.print ("ID: ");
  for (i=19; i<= 23; i++) {
    Serial.print (receive_ACK[i], HEX);
    Serial.print (" ");
  }
  Serial.println ();
}
 
 
void UART1_Send_Byte(unsigned char command_data)
{//send byte to device
  print1Byte(command_data);
#if defined(ARDUINO) && ARDUINO >= 100
  Serial1.flush();// complete the transmission of outgoing serial data
#endif
}
 
 
void UART_Send_Byte(unsigned char command_data)
{//send byte to PC
  Serial.print(command_data,HEX);
  Serial.print(" ");
}
 
 
void read_ACK(unsigned char temp)
{//read ACK into reveive_ACK[]
  unsigned char i;
  for(i=0;i<temp;i++) {
    receive_ACK[i]= Serial1.read();
  }
}
 
 
void wake_card(void)
{//send wake[] to device
  unsigned char i;
  for(i=0;i<24;i++) //send command
    UART1_Send_Byte(wake[i]);
}
 
 
void firmware_version(void)
{//send fireware[] to device
  unsigned char i;
  for(i=0;i<9;i++) //send command
    UART1_Send_Byte(firmware[i]);
}
 
 
void send_tag(void)
{//send tag[] to device
  unsigned char i;
  for(i=0;i<11;i++) //send command
    UART1_Send_Byte(tag[i]);
}
 
 
void display(unsigned char tem)
{//send receive_ACK[] to PC
  unsigned char i;
  for(i=0;i<tem;i++) //send command
    UART_Send_Byte(receive_ACK[i]);
  Serial.println();
}
 
 
//*********** end *************

le linee 036-048: definisci le costanti wake, firmware, tag, std_ACK, come array di tipo char ciascuno con una sequenza specifica di codici esadecimali utili ad una funzione che vedrai in seguito;

linee 049-051: definisci due variabili come array di char in cui memorizzerai i valori ricevuti dall’nfc arduino shield;

linee 054-062: rappresentano la possibilità di includere la libreria Arduino.h o la libreria WProgram.h in funzione della versione di IDE che stai utilizzanto, come sai dalla versione dell’IDE 1.0 la libreria Arduino.h sostituisce la WProgram.h;

linee 066-067: inizializza le due comunicazioni seriali sulla Serial e sulla Serial1 ( ecco perchè la scelta dell’arduino MEGA rende più semplice la riproduzione del progetto ). Nota che la velocità di comunicazione verso il monitor seriale è impostata a 9600 e quella verso l’NFC è impostata a 115200;

linee 069-073: richiami in sequenza le funzioni:

  • wake_card()
  • read_ACK(15)
  • display(15)

intervallando ciascuna funzione da 100 millisecondi di delay;

linea 078: inizia la funzione loop(), decisamente compatta, io la preferisco in quanto fa uso di altre funzioni definite dopo;

linea 080: richiami la funzione send_tag() definita alla linea 177;

linea 081: invoca la funzione read_ACK(25) definita alla linea 152;

linea 083: controlla il return code della funzione cmp_id(9 e se false procede ad eseguire le linee successive;

linee 084-087: esegui il test_ACK() e verifica il codice restituito, in caso di test positivo richiami la funzione display() e attendi 100 millisecondi;

linea 089: richiama la funzione copy_id() definita alla linea 093;

linea 093: definisci la prima delle funzioni personalizzate dello sketch copy_id() richiamata dalla loop();

linea 095: crea due variabili di tipo integer ai e oi che userai di seguito;

linee 096-098: definisci un ciclo for con due variabili ( ai ed oi ) in cui ai parte da 19, la condizione di verifica è impostata solo sul valore massimo di oi (5) e sia ai sia oi vengono incrementate contemporaneamente. In questo modo inserirai i valori dell’indice 19,20,21,22 e 23 restituiti dalla funzione receive_ACK nella variabile old_id alla posizione 0,1,2,3,4;

linea 102: crea la funzione cmp_id() che ha lo scopo di comparare l’id ricevuto con l’old id memorizzato;

linee 105-109: inizia un ciclo a due variabili ed una condizione simile a quello definito alla linea 096 la cui finalità è descritta dalla condizione di if presente alla linea 106 in cui confronti i valori presenti nell’old_id con quelli del receive_id per gli ultimi 5 digit al primo digit differente la funzione restituisce 0 altrimenti restituisce 1;

linee 113-121: crea la funzione test_ACK() che restituisce true ( 1 ) se il confronto tra i valori ricevuti dall’nfc arduino ha i primi 19 digit compatibili con lo standard definito mediante la str_ACK() definita alla line 045;

linee 124-133: la funzione send_id() scrive sul monitor seriale il valore dell’id nfc letto dalla shield. Il funzionamento è molto semplice se conosci com funziona un ciclo for ed il monitor seriale di arduino;

linee 136-142: è una delle due funzioni di comunicazione seriale. la UART1_Send_Byte quando viene invocata invia 1 byte alla Serial1 ossia verso l’nfc arduino;

linee 145-149; la UART_Send_Byte è una funzione identica alla precedente il cui scopo è inviare il valore passato in input alla porta Serial;

linee 152-158: definisci la funzione read_ACK() che si occupa di impostare il valore dell’array receive_ACK per la lunghezza passata come argomento dello stesso e prelevati dalla Serial1;

linee 161-166: la funzione wake_card() si occupa di inviare byte per byte alla shield nfc arduino il codice di inizializzazione presente nell’array wake ed utilizzando la funzione UART1_Send_Byte;

linee 169-174: la funzione firmware invia il valore della variabile firmware all’NFC un byte alla volta mediante la funzione UART1_Send_Byte. Non viene richiamata da nessun’altra funzione in questo sketch;

linee 177-182: definisci la funzione send_tag() richiamata dalla loop() alla linea 080 il cui scopo è inviare il comando definito nella costante tag alla shield nfc arduino;

linee 185-191: è la funzione display() che si preoccupa di visualizzare sul monitor seriale i valori del tag letto dall’NFC scrivendolo byte per byte grazie alla funzione UART_Send_Byte;

Deduzioni dallo sketch

Osservando l’analisi linea per linea dello sketch avrai notato che i primi 19 byte del tag NFC si riferiscono alla tipologia di tag e che solo i restanti 5 sono considerati significativi per il riconoscimento del tag.

Questa informazione può tornarti utile nel momento in cui andrai a memorizzare i tag in un file o altro sistema in grado di eseguire il confronto tra il valore letto e quelli memorizzati.

Il video

Ho realizzato un video in cui puoi vedere diversi tipi di tag NFC ossia le chiavi che possono essere riconosciute dalla shield nfc arduino.

Il video mostra nelle prime righe il riconoscimento dei TAG e nella parte finale ho ripetuto la lettura dell’ultimo Tag Nfc arduino per controllare che il codice letto fosse sempre il medesimo.

Cortesemente, prima di inserire i commenti leggi il regolamento

Permanent link to this article: http://www.mauroalfieri.it/elettronica/nfc-arduino.html

16 comments

1 ping

Skip to comment form

    • manuel on 17 maggio 2014 at 07:42
    • Reply

    buon giorno mauro
    mi chiamo manuel e un apassionato di elettronica devo contattarti x email xche mi sono cimentato a costruire il leo wi rover5 e devo chiederti delle delucidazioni
    nei contatti non riesco a decifrare la tua mail…

    grazie

    1. Ciao Manuel,
      la casella email dei contatti è scritta in notazione antispam at = @ e dot = . il resto sono certo che sai leggerlo.
      Per quanta riguarda il tuo esperimento mi poiacerebbe condividerlo con gli appassionati e lettori del blog come te.
      Se vuoi puoi usare l’email per inviarmi foto, video, sketch e testo da scrivere nel tuo articolo.

      Per i consigli ed i dubbi ti chiedo di usare i commenti in quanto sono più rapido nelle risposte.
      Ricorda che il codice degli sketch è cancellato automaticamente se lo inserisci nei commenti ed in ogni caso non correggo o riscrivo codice scritto da altri perchè mi piace che ci proviate voi a fare le correzioni.

      P.S.: usa i commenti degli articoli corretti, questo articolo non parla del Rover Leo Wi

    • adrian on 6 ottobre 2014 at 16:22
    • Reply

    I try to copy that code to arduino software and there are some error. After i fix the code, and then i upload to my arduino mega for do the test with tag which is card 13.56mhz and the nfc not response anything. Can you send me your code exactly the same with code you use in video. I am very need that code to complete my bachelors degree project. Please 🙂

    1. Hi Adrian,
      i think you use a different HFC shield.
      Code used in my video is write in post, can you verify the model and type of nfc shield ?

        • adrian on 7 ottobre 2014 at 02:15
        • Reply

        I use exactly the same NFC , what is your email? . i will send you a pict of my NFC. Or you can send me the step in detail to my email : mohadrianfaisal@gmail. Com. Thank you very much.

        1. Hi Adrian,
          if your NFC is the same on this post the sketch is correct.
          You can found the sketch on wiki dfrobot.

    • Marco on 13 ottobre 2014 at 12:13
    • Reply

    Salve, vorrei avere delle informazioni su arduino e NFC. Allora io vorrei sviluppare un’applicazione android che mi consenta di comunicare con arduino mediante NFC. Es. un’applicazione stupida che mediante un bottone mi faccia accendere un led. Il dubbio è che non sono sicuro se si possa fare una cosa del genere con NFC. Grazie mille.

    1. Ciao Marco,
      per quel poco che io conosco dell’NFC penso sia un sistema ideato per tutt’altro scopo.
      Puoi far in modo che android si comporti come un dispositivo NFC e sia riconosciuto dal tuo progetto arduino.
      NFC non mi risulta un sistema di comunicazione wifi o similare.

        • Marco on 14 ottobre 2014 at 17:32
        • Reply

        Ho capito, ma se la mia applicazione android scrivesse semplicemente sulla scheda NFC di arduino (perchè ho letto che funge anche da tag NFC , mi corregga se sbaglio), poi arduino dovrebbe essere in grado di leggere il valore dalla scheda o no ? p.s. praticamente sto facendo una tesi di laurea ed ho questo problema, ma l’ho generalizzato dicendo di accendere un led, ma mi basta che legga un valore dalla scheda, in modo che possa di conseguenza fare una determinata azione, non so se mi sono spiegato. Grazie dell’attenzione.

        1. Ciao Marco,
          la shield che ho utilizzato io per questo progetto non ha la possibilità di memorizzare nulla, semmai è arduino che quando avvicini un tag NFC lo riconosce e può utilizzarlo come preferisci.
          Ti consiglio la lettura del sistema NFC su Wikipedia o altro sito in cui è descritto come è stato concepito e come va utilizzata la tecnologia NFC.

    • Alessandro on 25 febbraio 2016 at 13:34
    • Reply

    Ciao Mauro credi sia possibile con Arduino creare un dispositivo NFC reader/writer con schermo LCD portatile?

    1. Ciao Alessandro,
      hai descritto troppi pochi dettagli, tuttavia penso sia possibile.

        • Alessandro on 26 febbraio 2016 at 20:34
        • Reply

        Ora mi spiego meglio, l’idea é di creare un dispositivo NFC palmare che possa visualizzare e scrivere i tag nfc, dotato quindi di un LCD sufficientemente ampio. In commercio son pochi e costano molto. Fino ad ora riesco solo a visualizzare i tag su un LCD 16×02 ma sempre scritti con l’uso del PC. Aggiungendo un display TFT da 3.2″ é possibile scrivere tag senza il computer?
        Grazie per la pazienza

        1. Ciao Alessandro,
          leggo confusione, un aspetto è il display ed un’altro la lettura/scrittura NFC.
          Se la domanda è “é possibile scrivere tag senza il computer?” la risposta è: Si.

    • Claudio on 18 gennaio 2017 at 23:14
    • Reply

    Ciao Mauro, io dovrei utilizzare la tecnologia nfc per trasferire i dati dal dispositivo fatto con arduino al telefono ma non so come fare e su internet non ho trovato nulla, mi puoi aiutare?

    1. Ciao Claudio,
      lascio on-line il tuo commento in modo che altri appassionati possano contribuire. Io non ho mai fatto nulla del genere.

  1. […] passato hai letto dei miei test con una shield simile della DF Robot: NFC Arduino in cui avevo testato la mia shield NFC prodotta dalla DF […]

Lascia un commento

Your email address will not be published.

This site uses Akismet to reduce spam. Learn how your comment data is processed.