Il modulo PN532 NFC RFID - Comunicazione in campo vicino

RFID? NFC? Che cos'è?

In questo articolo vogliamo mostrarti come leggere i tag ID. Il fulcro dell'articolo è il modulo PN532 NFC RFID. 

Il modulo si basa sul chip PN532 di NXP. Questo chipset è molto utilizzato nel campo dell'NFC (Near Field Communication). Un oggetto abilitato alla NFC, spesso una carta assegni con un chip NFC, viene avvicinato a un lettore NFC. In questo modo è possibile scambiare informazioni in una frazione di secondo. 

Ti sembra astratto? Se hai una carta EC più recente e la usi per i pagamenti contactless, allora conosci l'NFC anche nella vita di tutti i giorni. Appoggiando la carta sul terminale, la transazione viene avviata in modo semplice e veloce.

Vogliamo dare un'occhiata più da vicino ai processi tecnici che stanno alla base di tutto questo. Il modulo PN532 è ideale per questo scopo, in quanto è in grado di gestire sia I2C che SPI. Il tipo di comunicazione desiderata può essere selezionata direttamente sulla scheda PN532, agendo sugli interruttori presenti su di essa. La posizione degli interruttori necessaria per le rispettive interfacce si trova a destra dello schema elettrico, un po' più in basso nella pagina.

Lo schema elettrico:

Suggerimento: puoi trovare una versione ad alta risoluzione di questa immagine qui. Qui puoi vedere meglio l'assegnazione dei pin.

Il codice del programma (versione I2C)

//*******************************************************************************************************
//** Schizzo di esempio per la lettura di tag ID. Se l'ID corrisponde, il PIN 13 viene acceso per 2 secondi **
//** si accende (LED). Se l'ID è sbagliato, viene generato un segnale acustico al pin 12. (cicalino passivo / piezzo) **
//** utilizzo. Al posto del LED, è possibile attivare la serratura della porta (tramite l'amplificatore di commutazione TIP120)
//*******************************************************************************************************
#include <Wire.h> // Libreria per il protocollo I2C
#include <Adafruit_PN532.h> // Libreria per il modulo NFC/RFID!!!  Si prega di caricare tramite l'IDE Arduino!!!
#define PN532_IRQ (2) // Definisce il connettore IRQ
#define PN532_RESET (3) // Definisce il collegamento di reset
const int AlarmPin = 12; // Uscita pin 12 per l'altoparlante piezoelettrico
const int OutputPin = 13; // Uscita del pin 13 per il LED o per il blocco magnetico tramite TIP120
unsigned long cardid; // Variabile per la lettura del TAG-ID
unsigned long TAGid1 = 1702536620; // Gli ID da accettare possono essere inseriti qui
unsigned long TAGid2 = 4070796058; // Altrimenti lascia in bianco. L'ID dei singoli TAG può essere inserito con
unsigned long TAGid3 ; // il monitor seriale (impostare 115200 baud)
Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET); // Crea un'istanza con il protocollo I2C
void  setup() { // avvia la funzione di setup
pinMode(AlarmPin, OUTPUT); // Definisce il PIN come uscita
pinMode(OutputPin, OUTPUT); // Definisceil PIN come uscita
Serial.begin(115200); // Aprire la trasmissione seriale con 115200 baud (ser monitorare la stessa impostazione di baud!)
Serial.println("Ciao!"); // Invia il testo "Ciao!" al monitor seriale
nfc.begin(); //  Inizia la comunicazione con il lettore RFID
unsigned long versiondata = nfc.getFirmwareVersion(); // Leggi il numero di versione del firmware
if (! versiondata) {                                   // Wenn keine Antwort kommt
Serial.print("Kann kein Board finden !");            // Sende Text "Kann kein..." an seriellen Monitor
while (1);                                           // so lange Stopp
}
Serial.print("Chip PN5 trovato"); Serial.println((versiondata >> 24) & 0xFF, HEX); // Invia testo e informazioni sulla versione allaporta  serialedel lettore RFID
Serial.print("Firmware ver. "); Serial.print((versiondata >> 16) & 0xFF, DEC); // Controlla quando arriva la risposta dalla scheda
Serial.print('.'); Serial.println((versiondata >> 8) & 0xFF, DEC); // 
nfc.SAMConfig(); // Configura la scheda per leggere i tag RFID
Serial.println("In attesa di un chip ISO14443A ..."); // Invia il testo in attesa al monitor seriale
}
void loop() { // Avvia la funzione loop
uint8_t success; // Crea una variabile
uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 }; // Buffer per memorizzare l'UID
uint8_t uidLength; // Lunghezza dell'UID (4 o 7 byte a seconda del tipo di scheda/chip ISO14443A)
// Attendere un chip ISO14443A. Se ne viene rilevato uno, la variabile
// viene riempita con l'UID. A seconda della lunghezza (4 byte (Mifare Classic) o 7 byte (Mifare Classic)
// 7 byte (Mifare Ultralight) viene riconosciuto il tipo di carta.
success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength);
if (success) { // Se viene rilevato, elabora....
Serial.println("Trovata una carta ISO14443A");
Serial.print(" Lunghezza UID: "); Serial.print(uidLength, DEC); Serial.println(" bytes");
Serial.print(" Valore UID: ");
nfc.PrintHex(uid, uidLength); // invio delle informazioni al monitor seriale
se (uidLength == 4) {                                  // Hat die Karte/der Chip 4 byte Länge...
// Mifare Classic Karte
cardid = uid[0];                                     //
cardid <<= 8;                                        // Setze die 4 byte Blöcke
cardid |= uid[1];                                    //
cardid <<= 8;                                        // zu einem einzigen Block
cardid |= uid[2];                                    //
cardid <<= 8;                                        // zusammen
cardid |= uid[3];                                    //
Serial.print("Scheint eine Mifare Classic zu sein #");  //
Serial.println(cardid);                                 // Gib die Informationen aus
Serial.println("");                                     // 
Serial.println("");                                     // 
}
if ((cardid) == (TAGid1)||(cardid) == (TAGid2)||(cardid) == (TAGid3)) // interroga se i TAG 1..2..3 sono collegati con il rispettivo
{digitalWrite(OutputPin,HIGH);                                                // überein stimmt. Dann schalte je nach dem
delay(2000);
digitalWrite(OutputPin,LOW);}                                               // On o off
altrimenti
{tone(AlarmPin, 1000);                                                        // Und gib ggf. einen Ton/Frequenz aus
delay(4000);
noTone(AlarmPin);}
} // Fine della query/loop IF
} // Fine del ciclo

Il codice del programma (versione SPI)

//*******************************************************************************************************
//** Esempio di sketch per la lettura di tag ID. Se l'ID è adatto, il PIN 13 viene ** per 2 secondi
//** si accende (LED). Se l'ID è sbagliato, viene generato un segnale acustico al pin 12. (cicalino passivo / piezzo) **
//** utilizzo. Al posto del LED, è possibile attivare la serratura della porta (tramite l'amplificatore di commutazione TIP120)
//*******************************************************************************************************
#include <Wire.h> // Libreria per il protocollo I2C
#include <SPI.h> // Libreria per il protocollo SPI
#include <Adafruit_PN532.h> // Libreria per il modulo NFC/RFID !!! Si prega di caricarla tramite l'IDE Arduino!!!
const byte PN532_SCK = 2; //
const byte PN532_MOSI =3; // Definisci le connessioni per 
const byte PN532_SS = 4; // la connessione SPI all'RFID 
const byte PN532_MISO =5; // Scheda
const int AlarmPin = 12; // Definisci le connessioni per
const int OutputPin = 13; // le uscite (di commutazione)
unsigned long cardid; // Variabile per la lettura del TAG-ID
unsigned long TAGid1 = 1702536620; // gli ID da accettare possono essere inseriti qui
unsigned long TAGid2 = 4070796058; // Altrimenti lascia in bianco. L'ID dei singoli TAG può essere inserito con
unsigned long TAGid3 ; // il monitor seriale (impostare 115200 baud)
Adafruit_PN532 nfc(PN532_SCK, PN532_MISO, PN532_MOSI, PN532_SS); // crea un'istanza con protocollo SPI
void  setup() { // Avvia la funzione di setup
pinMode(AlarmPin, OUTPUT); // Definisce il PIN come uscita
pinMode(OutputPin, OUTPUT); // Definisceil PIN come uscita
Serial.begin(115200); // Aprire la trasmissione seriale con 115200 baud (ser monitorare la stessa impostazione di baud!)
Serial.println("Ciao!"); // Invia il testo "Ciao!" al monitor seriale
nfc.begin(); //  Inizia la comunicazione con il lettore RFID
unsigned long versiondata = nfc.getFirmwareVersion(); // Leggi il numero di versione del firmware
if (! versiondata) {                                   // Wenn keine Antwort kommt
Serial.print("Kann kein Board finden !");            // Sende Text "Kann kein..." an seriellen Monitor
while (1);                                           // so lange Stopp
}
Serial.print("Trovato chip PN5"); Serial.println((versiondata >> 24) & 0xFF, HEX); // Invia il testo e le informazioni sulla versione allaporta  serialedel lettore RFID
Serial.print("Firmware ver. "); Serial.print((versiondata >> 16) & 0xFF, DEC); // Controlla quando arriva la risposta dalla scheda
Serial.print('.'); Serial.println((versiondata >> 8) & 0xFF, DEC); // 
nfc.SAMConfig(); // Configura la scheda per leggere i tag RFID
Serial.println("In attesa di un chip ISO14443A ..."); // Invia il testo in attesa al monitor seriale
}
void loop() { // Avvia la funzione loop
uint8_t success; // Crea una variabile
uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 }; // Buffer per memorizzare l'UID
uint8_t uidLength; // Lunghezza dell'UID (4 o 7 byte a seconda del tipo di scheda/chip ISO14443A)
// Attendere un chip ISO14443A. Se ne viene rilevato uno, la variabile
// viene riempita con l'UID. A seconda della lunghezza (4 byte (Mifare Classic) o 7 byte (Mifare Classic)
// 7 byte (Mifare Ultralight) viene riconosciuto il tipo di carta.
success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength);
if (success) { // Se viene rilevato, elabora....
Serial.println("Trovata una carta ISO14443A");
Serial.print(" Lunghezza UID: "); Serial.print(uidLength, DEC); Serial.println(" bytes");
Serial.print(" Valore UID: ");
nfc.PrintHex(uid, uidLength); // invio delle informazioni al monitor seriale
se (uidLength == 4) {                                  // Hat die Karte/der Chip 4 byte Länge...
// Mifare Classic Karte
cardid = uid[0];                                     //
cardid <<= 8;                                        // Setze die 4 byte Blöcke
cardid |= uid[1];                                    //
cardid <<= 8;                                        // zu einem einzigen Block
cardid |= uid[2];                                    //
cardid <<= 8;                                        // zusammen
cardid |= uid[3];                                    //
Serial.print("Scheint eine Mifare Classic zu sein #");  //
Serial.println(cardid);                                 // Gib die Informationen aus
Serial.println("");                                     // 
Serial.println("");                                     // 
}
if ((cardid) == (TAGid1)||(cardid) == (TAGid2)||(cardid) == (TAGid3)) // interroga se i TAG 1..2..3 sono collegati con il rispettivo
{digitalWrite(OutputPin,HIGH);                                                // überein stimmt. Dann schalte je nach dem
delay(2000);
digitalWrite(OutputPin,LOW);}                                               // On o off
altrimenti
{tone(AlarmPin, 1000);                                                        // Und gib ggf. einen Ton/Frequenz aus
delay(4000);
noTone(AlarmPin);}
} // Fine della query/loop IF
} // Fine del ciclo