Módulo RFID NFC PN532 - Comunicación de campo cercano

¿RFID? ¿NFC? ¿Qué es eso?

En este artículo, nos gustaría mostrarte cómo leer etiquetas de identificación. El artículo se centra en el módulo RFID PN532 NFC. 

El módulo se basa en el chip NXP PN532. Este chipset se utiliza ampliamente en el campo de la NFC (Comunicación de Campo Cercano). Un objeto habilitado para NFC, a menudo una tarjeta cheque con un chip NFC, se acerca a un lector NFC. Esto permite intercambiar información en una fracción de segundo. 

¿Te parece abstracto? Si tienes una tarjeta CE más reciente y la utilizas para pagar sin contacto, entonces ya conoces la NFC incluso en la vida cotidiana. Al colocar la tarjeta en el terminal, se inicia la transacción, de forma rápida y sencilla.

Nos gustaría echar un vistazo más de cerca a los procesos técnicos que hay detrás de esto. El módulo PN532 es ideal para ello, ya que es capaz tanto de I2C como de SPI. El tipo de comunicación deseado se puede seleccionar directamente en la placa PN532 accionando los interruptores situados en ella. La posición de los interruptores necesaria para cada interfaz se encuentra a la derecha del esquema de conexiones, un poco más abajo.

El esquema del circuito:

Consejo: Puedes encontrar una versión de alta resolución de esta imagen aquí. Allí puedes ver la asignación de pines un poco mejor.

El código del programa (versión I2C)

//*******************************************************************************************************
//** Esquema de ejemplo para leer etiquetas de identificación. Si el ID coincide, el PIN 13 se enciende durante 2 segundos **
//** se enciende (LED). Si el ID es erróneo, se genera un tono en el pin 12. (zumbador / piezzo pasivo) **
//** uso. En lugar de un LED, también se puede conmutar una cerradura de puerta (mediante el amplificador de conmutación TIP120 **
//*******************************************************************************************************
#include <Wire.h> // Biblioteca para el protocolo I2C
¡¡¡#include <Adafruit_PN532.h > // Biblioteca  para el módulo NFC/RFID!!!  ¡¡¡Por favor, cárgala a través del IDE de Arduino !!!
#define PN532_IRQ (2) //  Define el conector IRQ
#define PN532_RESET (3) // Define  la conexión reset
const int ClavijaAlarma = 12; //  Clavija 12 salida para altavoz piezoeléctrico
const int SalidaPin = 13; // Salida pin 13  para LED o mediante TIP120 a una cerradura magnética
unsigned long cardid; //  Variable para el TAG-ID de lectura
unsigned long TAGid1 = 1702536620; //  Aquí se pueden introducir los ID que se van a aceptar
unsigned long TAGid2 = 4070796058; //  Si no, déjalo en blanco. El ID de los TAG individuales se puede introducir con
unsigned long TAGid3 ; //  el monitor serie (establecer 115200 baudios)
Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET); // Crear instancia con protocolo I2C
void  setup() { // inicia la función de configuración
pinMode(PinAlarma, OUTPUT); //  Define el PIN como salida
pinMode(ClavijaSalida, OUTPUT); // Define el PIN  comosalida
Serial.begin(115200); // Abre la transmisión serie con 115200 baudios (¡ser monitoriza la misma configuración de baudios!)
Serial.println("¡Hola!"); //  Envía el texto "¡Hola!"al monitor serie
nfc.begin(); // Iniciar la comunicación con el lector RFID
unsigned long versiondata = nfc.getFirmwareVersion(); //  Leer el número de versión 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 encontrado"); Serial.println((versiondata >> 24) & 0xFF, HEX); //  Enviar texto e información de la versiónal puerto  seriedel lector RFID
Serial.print("Firmware ver. "); Serial.print((versiondata >> 16) & 0xFF, DEC); // Monitoriza cuándo llega la respuesta de la placa
Serial.print('.'); Serial.println((versiondata >> 8) & 0xFF, DEC); // 
nfc.SAMConfig(); // Configura la placa para leer etiquetas RFID
Serial.println("Esperando un chip ISO14443A ..."); // Envía el texto que espera al monitor serie
}
void bucle() { // Iniciar función bucle
uint8_t éxito; // Crear variable
uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 }; // Búfer para almacenar el UID
uint8_t uidLength; // Longitud del UID (4 ó 7 bytes según el tipo de tarjeta/chip ISO14443A)
// Espera a que haya un chip ISO14443A. Si se detecta uno, la variable
// se rellena con el UID. Dependiendo de la longitud (4 bytes (Mifare Classic) o
// 7 bytes (Mifare Ultralight) se reconoce el tipo de tarjeta.
éxito = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength);
if (éxito) { // Si se detecta, procesa....
Serial.println("Encontrada una tarjeta ISO14443A");
Serial.print(" Longitud UID: "); Serial.print(uidLength, DEC); Serial.println(" bytes");
Serial.print(" Valor UID: ");
nfc.PrintHex(uid, uidLength); // envía la información al monitor serie
if (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)) //  consulta si los TAGs 1..2..3 están conectados con el respectivo
{digitalWrite(OutputPin,HIGH);                                                // überein stimmt. Dann schalte je nach dem
delay(2000);
digitalWrite(OutputPin,LOW);}                                               // Encendido o apagado
si no
{tone(AlarmPin, 1000);                                                        // Und gib ggf. einen Ton/Frequenz aus
delay(4000);
noTone(AlarmPin);}
} // Fin de la consulta/bucle IF
} // Fin del  bucle

El código del programa (versión SPI)

//*******************************************************************************************************
//** Sketch de ejemplo para leer etiquetas de identificación. Si el identificador es adecuado, el PIN 13 ** durante 2 segundos
//** se enciende (LED). Si el ID es erróneo, se genera un tono en el pin 12. (zumbador / piezzo pasivo) **
//** uso. En lugar de un LED, también se puede conmutar una cerradura de puerta (mediante el amplificador de conmutación TIP120 **
//*******************************************************************************************************
#include <Wire.h> //  Biblioteca para el protocolo I2C
#include <SPI. h> // Biblioteca para  el protocolo SPI
¡¡¡#include <Adafruit_PN532.h > //  Biblioteca para el módulo NFC/RFID !!! ¡¡¡Cárgala a través del IDE de Arduino !!!
const byte PN532_SCK = 2; //
const byte PN532_MOSI =3; //  Define las conexiones para 
const byte PN532_SS = 4; //  la conexión SPI al RFID 
const byte PN532_MISO =5; //  la placa
const int ClavijaAlarma = 12; //  Define las conexiones para
const int ClavijaSalida = 13; //  las salidas (de conmutación)
unsigned long cardid; //  Variable para el TAG-ID leído
unsigned long TAGid1 = 1702536620; // Aquí se pueden introducir los ID que se van a aceptar
unsigned long TAGid2 = 4070796058; //  Si no, déjalo en blanco. El ID de los TAG individuales se puede introducir con
unsigned long TAGid3 ; //  el monitor serie (establecer 115200 baudios)
Adafruit_PN532 nfc(PN532_SCK, PN532_MISO, PN532_MOSI, PN532_SS); // crea una instancia con protocolo SPI
void  setup() { // Inicia la función de configuración
pinMode(PinAlarma, OUTPUT); // Define el PIN como salida
pinMode(ClavijaSalida, OUTPUT); //  Defineel PIN como salida
Serial.begin(115200); // Abre la transmisión serie con 115200 baudios (¡ser monitoriza la misma configuración de baudios!)
Serial.println("¡Hola!"); //  Envía el texto "¡Hola!"al monitor serie
nfc.begin(); // Iniciar la comunicación con el lector RFID
unsigned long versiondata = nfc.getFirmwareVersion(); //  Leer el número de versión 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("Encontrado chip PN5"); Serial.println((versiondata >> 24) & 0xFF, HEX); //  Enviar texto e información de la versión alpuerto  seriedel lector RFID
Serial.print("Firmware ver. "); Serial.print((versiondata >> 16) & 0xFF, DEC); // Monitoriza cuándo llega la respuesta de la placa
Serial.print('.'); Serial.println((versiondata >> 8) & 0xFF, DEC); // 
nfc.SAMConfig(); // Configura la placa para leer etiquetas RFID
Serial.println("Esperando un chip ISO14443A ..."); // Envía el texto que espera al monitor serie
}
void bucle() { // Iniciar función bucle
uint8_t éxito; // Crear variable
uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 }; // Buffer para almacenar el UID
uint8_t uidLength; // Longitud del UID (4 ó 7 bytes según el tipo de tarjeta/chip ISO14443A)
// Espera a que haya un chip ISO14443A. Si se detecta uno, la variable
// se rellena con el UID. Dependiendo de la longitud (4 bytes (Mifare Classic) o
// 7 bytes (Mifare Ultralight) se reconoce el tipo de tarjeta.
éxito = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength);
if (éxito) { // Si se detecta, procesa....
Serial.println("Encontrada una tarjeta ISO14443A");
Serial.print(" Longitud UID: "); Serial.print(uidLength, DEC); Serial.println(" bytes");
Serial.print(" Valor UID: ");
nfc.PrintHex(uid, uidLength); // envía la información al monitor serie
if (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)) //  consulta si los TAGs 1..2..3 están conectados con el respectivo
{digitalWrite(OutputPin,HIGH);                                                // überein stimmt. Dann schalte je nach dem
delay(2000);
digitalWrite(OutputPin,LOW);}                                               // Encendido o apagado
si no
{tone(AlarmPin, 1000);                                                        // Und gib ggf. einen Ton/Frequenz aus
delay(4000);
noTone(AlarmPin);}
} // Fin de la consulta/bucle IF
} // Fin del  bucle