NFC 532 y ESP32 o UNO o Nano

INFORMACIÓN
El módulo PN532 RFID/NFC es un dispositivo electrónico que permite leer y escribir en tags,
comunicarse con teléfonos que soportan NFC e incluso actuar como un tag RFID/NFC. Si lo que
deseas es evaluar el PN532, o realizar investigación y desarrollo en el campo de NFC o RFID,
esta tarjeta es ideal para dicha aplicación; esa u otras aplicaciones en RFID/NFC pueden ser con
Arduino o Raspberry Pi. Posee 3 interfaces de comunicación para utilizar con otros
µcontroladores.
Cabe mencionar que es muy flexible y permite comunicación con µcontroladores a través del
UART a 3,3 V, el I2C o el SPI, solo debe configurarse correctamente el DIP-SWITCH de acuerdo
a la interfaz de comunicación que desee utilizarse. El chip está bien soportado por libnfc (una
librería para desarrollar aplicaciones con NFC). Otra opción es conectar directamente un cable
USB-Serial al UART de esta tarjeta para comenzar a trabajar con el PN532 en tu PC.
ESPECIFICACIONES Y CARACTERÍSTICAS
 Tipo: Kit Módulo NFC RFID
 Incluye: Módulo PN532, Tarjeta RFID Mifare 1k S50 blanca y TAG RFID Mifare 1k tipo llavero
 Voltaje de funcionamiento: 3,3 V a 5 V
 Frecuencia de operación: 13,56 MHz
 Interfaz de comunicación: SPI, I2C, High-speed UART (HSU)
 Transferencia de datos: Max. 10 Mbit/s
 Compatible con el estándar: RFID ISO/IEC 14443-A y NFC: ISO/IEC 18092
 Tipos de tarjetas compatibles: Mifare 1 k S50, S70 Mifare1, Mifare Ultralight, Mifare Pro,
Mifare DESFire, Mifare Classic.
 Dimensiones: 41x43 mm
TUTORIALES
 Datasheet
 Adafruit-PN532 – Librería
 Elechouse-PN532 – Librería
 UNIT_PN532 – Librería
 Pinout
 Fritzing PN532
INFORMACIÓN ADICIONAL
¿Módulo RFID PN532 cómo funciona?
El PN532 incluye un procesador 80C51 con 40 kB ROM y 1 KB RAM, junto con los elementos
necesarios para hacer funcionar correctamente la comunicación NFC.
Soporta 6 modos de operación:
 ISO/IEC 14443A/MIFARE
 Lector/Grabador, Card MIFARE Classic 1 k y MIFARE Classic 4 k Card
 Lector/Grabador ISO/IEC 14443B
 FeliCa Lector/Grabador y Card emulación
 ECMA 340 Peer-to-Peer ISO/IEC 18092
La distancia típica de actuación es de 50 mm para lectura y escritura, y 100 mm para emulación.
La velocidad de lectura es de hasta 212 kbits/s y la de escritura de hasta 424 kbits/s. Estos valores
dependen, entre otros, de la antena integrada en el módulo.
 El PN532 opera a 3,3 V pero admite tensiones de alimentación de 2,7 V a 5,4 V. Las líneas de
comunicación I2C/UART funcionan de 3,3 V a 24 V TTL. Sin embargo, la interface SPI funciona
a 3,3 V, pero incorpora resistencias de 100 Ω en serie para que también pueda conectarse a 5 V.
El consumo es de 100 mA en modo Stand-By y 120 mA durante la lectura y escritura.
Adicionalmente dispone de dos modos de baja energía: un modo Soft-Power-Down de un
consumo de 22 µA, y un modo Hard-Power-Down con un consumo de 1µA.
De igual manera puede usarse con ordenadores y µordenadores como Raspberry Pi con la librería
libnfc.
ENLACES EXTERNOS
 Arduino con PN532 NFC RFID
 Lector y escritor RFID / NFC con PN532
******************************************************************************
RFID NFC532-V2

Kit de desarrollo RFID RC522

Este kit de desarrollo RFID RC522 se basa en un lector/grabador IC MFRC522 de NXP
altamente integrado para la comunicación sin contacto a 13,56 MHz. El lector MFRC522 soporta
ISO/IEC 14443 A/MIFARE y NTAG. El transmisor interno del MFRC522 puede controlar una
antena de lectura/escritura diseñada para comunicarse con tarjetas y transpondedores ISO/IEC
14443A sin circuitos activos adicionales. El módulo receptor proporciona una implementación
robusta y eficiente para demodular y decodificar señales de tarjetas y transpondedores.

SKU: MDU1040
Resumen de Datos:
 Tensión de funcionamiento: 2,5 V a 3,3 V.
 Corriente de funcionamiento/espera: 13 a 26 mA/10 a 13 mA.
 Frecuencia de funcionamiento: 13,56 MHz.
 Soporta comunicación de mayor velocidad de transferencia ISO/IEC 14443A hasta 848
kBd.
 Velocidad de bus SPI hasta 10 Mbit/s.
 Interfaz bus I2C hasta 400 kBd en modo rápido, hasta 3400 kBd en modo de alta
velocidad.
 UART serie RS232 de hasta 1.228,8 kBd, con niveles de tensión dependientes de la
tensión del pin de los pines.
 Compatible con tarjetas MIFARE e ISO 14443A.
  Distancia operativa típica en modo Lectura/Escritura de hasta 50 mm dependiendo del
tamaño y sintonización de la antena.

Función de los pines de interfaz:

P.D: Este módulo no soporta tarjetas RFID que operan

en el rango de frecuencia de 125 kHz. Sólo es
compatible con las tarjetas que operan en el rango de
frecuencia de 13,56 MHz.

Ejemplo de aplicación con Arduino:

Descarga de la librería:
Aquí tienes la librería que necesitas para este proyecto:
1. Descarga aquí la librería RFID creada por miguelbalboa.
2. Descomprime la librería RFID.
3. Instala la librería RFID en tu IDE Arduino.
4. Reinicia el IDE Arduino.
Conexión del circuito Arduino:

(Ejemplo de) Lectura de datos de una etiqueta RFID:

Después de tener el circuito listo, ir a ArchivoEjemplosMFRC522DumpInfo y cargue el
código. Este código estará disponible en tu IDE Arduino (después de instalar la librería RFID).
A continuación, abrir el monitor serie a 9600 baudios. Debería ver algo como la figura de abajo:
Acercar la tarjeta RFID o el llavero al lector. Dejar que el lector y la etiqueta se acerquen hasta
que aparezca toda la información como la de abajo, o parecida:

Esta es la información que puedes leer de la tarjeta, incluyendo el UID de la tarjeta que está
resaltado en rojo.
La información se almacena en la memoria que está dividida en segmentos y bloques como
puedes ver en la imagen anterior.
Tienes 1024 bytes de almacenamiento de datos divididos en 16 sectores y cada sector está
protegido por dos claves diferentes, A y B.
Anota tu tarjeta UID porque la necesitarás más adelante. En este caso, Tarjeta UID: B0 AC 7E
7A.
Carga el siguiente código en la placa Arduino:
====================================================================
/*
* All the resources for this project:
* Modified by Handson Technology
* [Link]
* Created by Handsontec Tech team
*/
#include <SPI.h> // Comunicación vía SPI, tomar la librería
#include <MFRC522.h> // Acceder a la librería del MFRC522
#define SS_PIN 10
#define RST_PIN 9
MFRC522 mfrc522(SS_PIN, RST_PIN); // Crear la instancia MFRC522.

void setup(){
[Link](9600); // Inicia la comunicación serial con PC/LapTop.
[Link](); // Inicia el bus SPI.
mfrc522.PCD_Init(); // Inicia el MFRC522.
[Link]("Aproxime su tarjeta al lector...");
[Link]();
}
void loop(){
// Ver por nuevas tarjetas
if (!mfrc522.PICC_IsNewCardPresent())
{return;}
// Select one of the cards
if (!mfrc522.PICC_ReadCardSerial())
{return;}
// Muestre la UID en el monitor serial.
[Link]("UID del tag :");
String content= "";
byte letter;
for (byte i = 0; i < [Link]; i++){
[Link]([Link][i] < 0x10 ? " 0" : " ");
[Link]([Link][i], HEX);
[Link](String([Link][i] < 0x10 ? " 0" : " "));
[Link](String([Link][i], HEX));
}
[Link]();
[Link]("Mensaje : ");
[Link]();
if ([Link](1) == "B0 AC 7E 7A") // Ponga acá las UIDs de tarjetas que tendrán acceso
{[Link]("Acceso Autorizado");
[Link]();
delay(3000);
}
else {
[Link](" Acceso negado");
delay(3000);
}
}
En el fragmento de código anterior debe cambiarse el if ([Link](1) == «REPLACE
WITH YOUR UID») y escribir la tarjeta UID que has escrito anteriormente… ó cambiar el if
([Link](1) == “REPLACE WITH YOUR UID”) y escriba la UID de la etiqueta
que escribió previamente.

Demostración:
Ahora, sube el código a tu Arduino y abre
el monitor serie. Verás la pantalla como la
de la derecha:

Acerca la tarjeta que has elegido para dar

acceso (en este caso con UID: B0 AC 7E
7A u otras tuyas que tengas disponibles) al
módulo lector y verás el resultado parecido
al que verás en la figura siguiente (en la
figura de abajo a la izquierda):

Ahora si pones cerca otra etiqueta con otro

UID que no haya sido colocado como
aceptable, aparecerá el mensaje de denegación
tal como se ve en la figura de abajo a la

derecha:
 Con esto hemos completado las pruebas iniciales y la configuración del módulo lector RFID
RC522, esperamos que este tutorial haya sido útil.
Este paquete de desarrollo RFID incluye:
 1x Módulo Lector RFID RC522
 1x Tarjeta RFID tamaño tarjeta de crédito (tipo M1 S50 IC Card)
 1x Llavero RFID (tipo M1 S50 Key tag)
 1x conector de cabecera recto de 8 patillas
 1x conector de cabecera en ángulo recto de 8 patillas
Recurso Web:
 [Link]
 Curso Uso del lector RFID MF522 con el Arduino.
 MF1 S50 ISO/IEC14443A Tarjeta RFID sin contacto
 Llavero RFID sin contacto MF1 S50 ISO/IEC14443A
/*****************************************************************************/
Módulo V3 NFC (RFID-PN532)
[Link]
srsltid=AfmBOor00WvW975AEefSTnE965B26yuss8GLhnV-wgc3jxezoE2WVz9Y

Lee tarjetas RFID con PN532 y ESP32

Para utilizar el lector RFID PN532 con
ESP32 es necesario modificar la librería
ya que la librería original de Adafruit
no es 100% compatible con un ESP32.
Para esto podemos: modificar la librería
directamente o podemos utilizar la
librería UNIT_PN532 que ya viene
modificada y solamente hay que
descargarla y agregarla a nuestro IDE.
Modificación a la librería
Para usar el lector PN532 con ESP32
hay que modificar la librería, ya que la
tasa de bits que viene predefinida en la
librería de Adafruit es demasiado rápida para el ESP32 por lo cual se debe modificar este dato para
poder utilizarlo con esta placa.
El problema que genera no modificar la tasa de bits, es la desconexión constante de la placa, el no
reconocimiento de la placa PN532, la no lectura de las tarjetas RFID o que el programa entre en un
bucle y se tenga que reiniciar constantemente la placa.
Solución
Hay dos soluciones para este problema, la primera es descargar la librería que se muestra a
continuación, esta librería ya está modificada para usarse con el ESP32 y que no genere ningún
error.
Librería UNIT_PN532
La segunda opción modifica la siguiente parte de código dentro de la librería original de Adafruit.
Tenemos que modificar el dato que está en el recuadro por el siguiente valor: “ 100000”, esto nos
dará una mejor comunicación con el ESP32 y así tendremos una conexión más estable entre el
PN532 y el ESP32. Esto sirve para la comunicación del PN532 por SPI, se recomienda usar SPI ya
que es más estable y la librería está mejor diseñada para ese tipo de comunicación.
Conexión ESP32 y PN532
Estas son las conexiones que tienen que
hacerse entre el lector PN532 y el ESP32, la
comunicación que estaremos manejando
será por SPI, revisa que tengas configurado
el PN532 para este tipo de comunicación.

Código con la librería UNIT_PN532:

//Declaración de Librerías
#include <Wire.h>
#include <SPI.h> // Librería para comunicación SPI
#include <UNIT_PN532.h> // ****Librería Modificada****

//Conexiones SPI del ESP32

#define PN532_SCK (18)
#define PN532_MOSI (23)
#define PN532_SS (5)
#define PN532_MISO (19)

uint8_t DatoRecibido[4]; // Para almacenar los datos

UNIT_PN532 nfc(PN532_SS); // Línea enfocada para la comunicación por SPI

void setup() {
[Link](115200); // Inicio de puerto Serial a 115200 baudios
[Link](); // Comienza la comunicación del PN532

uint32_t versiondata = [Link]();// Obtiene información de placa PN53x

if (! versiondata) { // Si no se encuentra comunicación con la placa: parar.

[Link]("No se encontró la placa PN53x");
while (1); // Detener
}
[Link]("Chip encontrado PN5"); // … sí se encontró comunicación
[Link]((versiondata >> 24) & 0xFF, HEX); //Imprime la versión del lector.
[Link]("Firmware ver. ");
 [Link]((versiondata >> 16) & 0xFF, DEC); // Imprime versión de firmware de la
placa
[Link]('.'); [Link]((versiondata >> 8) & 0xFF, DEC);

// Establezca el número máximo de reintentos para leer de una tarjeta.

// Esto evita que tengamos que esperar eternamente por una tarjeta, que es el
// comportamiento predeterminado del PN532.
[Link](0xFF);

[Link](); // Configura la placa para realizar la lectura

[Link]("Esperando una tarjeta ISO14443A ...");

}

void loop() {
boolean LeeTarjeta; // Variable para almacenar la detección de una tarjeta
uint8_t uid[] = {0, 0, 0, 0, 0, 0, 0}; // Búfer para almacenar la UID devuelta
uint8_t LongitudUID; // Variable para almacenar la longitud de la UID de la tarjeta

//Recepción y detección de los datos de la tarjeta y almacenamiento en la variable

"LeeTarjeta"
LeeTarjeta = [Link](PN532_MIFARE_ISO14443A, &uid[0], &LongitudUID);
// Indica si se detectó una tarjeta RFID y la lee

if (LeeTarjeta) { // Si se detecta la tarjeta

[Link]("Tarjeta encontrada!"); // indíquelo
[Link]("Longitud del UID: ");
[Link](LongitudUID, DEC); // Imprime la long. de datos de la tarj. en dec.
[Link](" bytes");
[Link]("Valor del UID: ");
// e imprima los datos almacenados en la tarjeta en Hexadecimal:
for (uint8_t i = 0; i < LongitudUID; i++)
{
[Link](" 0x"); [Link](uid[i], HEX);
}
[Link]("");
delay (1000); // Espera de 1 segundo
}

// Si no se detecta tarjeta:
else
{
[Link]("Se agotó el tiempo de espera de una tarjeta");
}
}

Este es el código de prueba para la tarjeta PN532, con este código podremos obtener la
información y el UID que se encuentra en la tarjeta, como se puede observar a continuación:
 Dispositivos: encontramos a continuación los links de las dos placas que se utilizaron,
para que puedan adquirirse al igual que los “links” a las tarjetas RFID.
 Kit Pn532 Nfc Lectura y Escritura V3
 ESP32 DEVKIT V1 30 Pines
 Tarjeta RFID 13.56 Mhz MFS50
 Llavero Tag RFID 13.56 MHz NFC
De Kit Pn532 Nfc Lectura y Escritura V3 tenemos:
INFORMACIÓN
El módulo Pn532 RFID/NFC es un dispositivo electrónico que permite leer y escribir en tags,
comunicarse con teléfonos que soportan NFC e incluso actuar como un tag RFID/NFC. Si sólo se
desea evaluar el PN532, o realizar investigación y desarrollo en el campo de NFC o RFID, esta
tarjeta es ideal para dicha aplicación.
Es ideal para desarrollar rápidamente aplicaciones en RFID/NFC con Arduino o Raspberry Pi.
Posee 3 interfaces de comunicación para utilizar con otros microcontroladores.
Cabe mencionar que es muy flexible y permite comunicación con microcontroladores a través de
UART a 3,3V, I2C o SPI, solo debe configurarse correctamente el DIP-SWITCH de acuerdo a la
interfaz de comunicación que desee utilizarse. El chip está bien soportado por libnfc (una librería
para desarrollar aplicaciones con NFC). Otra opción es conectar directamente un cable USB-
Serial al UART de esta tarjeta para comenzar a trabajar con el PN532 en tu PC.
ESPECIFICACIONES Y CARACTERÍSTICAS
 Tipo: Kit Módulo NFC RFID
 Incluye: Módulo PN532, Tarjeta RFID Mifare 1k S50 blanca y TAG RFID Mifare 1k tipo llavero
 Voltaje de funcionamiento: 3,3 V a 5 V
 Frecuencia de operación: 13,56 MHz
 Interfaz de comunicación: SPI, I2C, High-speed UART (HSU)
 Transferencia de datos: Max. 10 Mbit/s
 Compatible con el estándar: RFID ISO/IEC 14443-A y NFC: ISO/IEC 18092
 Tipos de tarjetas compatibles: Mifare 1K S50, S70 Mifare1, Mifare Ultralight, Mifare Pro,
Mifare DESFire, Mifare Classic.
 Dimensiones: 41x43 mm
******************************************************************************
De ESP32 DEVKIT V1 30 Pines tenemos:
INFORMACIÓN
ESP32 DEVKIT V1 es un microcontrolador de bajo costo y consumo de energía, cuenta con
tecnología Wi-Fi y Bluetooth de modo dual integrado que permite controlar todo tipo de
sensores, módulos y actuadores; es el sucesor del microcontrolador ESP8266.
ESP32 DEVKIT V1 permite generar proyectos de Internet de las cosas “IoT” de forma eficiente
y económica, ya que integra internamente una gran cantidad de periféricos incluyendo: sensores
táctiles capacitivos, sensor de efecto Hall, amplificadores de bajo ruido, interfaz para tarjeta SD,
Ethernet, SPI de alta velocidad, UART, I 2S e I2C. Tiene un CPU de dos núcleos de hasta 240
Mhz que se pueden controlar independientemente.
ESPECIFICACIONES Y CARACTERÍSTICAS
ESP32 DEVKIT V1 MicroUSB
ESP32 DEVKIT V1 USB-C
 Serie: ESP32 DEVKIT V1
 Puerto: USB-C
 Chip USB-Serial: CH340C
 Numero de Núcleos: 2
 Voltaje de Alimentación (USB): 5 VDC
 Voltaje de Entradas/Salidas: 3,3 VDC
 Consumo de 5 μA en modo de suspensión.
 Pines:
o Físicos: 30
o Digitales GPIO: 24 (Algunos pines solo
como entrada)
 Conversor Analógico Digital: Dos ADC de 12 bits tipo SAR, soporta mediciones en hasta
18 canales, algunos pines soportan un amplificador con ganancia programable.
 Antena en PCB
 Tipo: Módulo Wifi + Bluetooth
o Wifi: 802.11 b/g/n/e/i (802.11n @ 2,4 GHz hasta 150 Mbit/s)
o Bluetooth: 4.2 BR/EDR BLE Modo de control dual
 CPU principal: Tensilica Xtensa 32-bit LX6
 Memoria: 448 KByte ROM, 520 KByte SRAM, 6 KByte SRAM en RTC y QSPI admite
múltiples chips flash /SRAM
 Procesador secundario: Permite hacer operaciones básica en modo de ultra bajo consumo
 Desempeño: Hasta 600 DMIPS
 Frecuencia de Reloj: hasta 240 Mhz
 Seguridad: IEEE 802.11, incluyendo WFA, WPA/WPA2 y WAPI
 Criptografía acelerada por hardware: AES, SHA-2, RSA, criptografía de curva elíptica
(ECC), generador de números aleatorios (RNG)
Cómo programar ESP32 DEVKIT V1:
Ya instalado el controlador puede programarse en diferentes entornos de programación a elegir:
 Arduino IDE (en lenguaje C++),
 Esp-idf (Espressif IoT Development Framework) desarrollado por el fabricante del chip,
 Simba Embedded Programming Platform (en lenguaje Python)
 MicroPython
 Javascript (Espruino, Duktape, Mongoose JS)
 Y otros…
Es muy utilizado con Arduino IDE ya que cuenta con gran variedad de ejemplos, información y
otros recursos, que te ayudaran a comenzar a utilizar esta placa. Para utilizar con Arduino IDE
deberás realizar los siguientes pasos:
1. Abrir Arduino IDE. Si no lo has instalado descárgalo directamente de la página de Arduino,
instalar la versión ejecutable no instalar la versión portable.
2. Copiar el siguiente URL: [Link]
3. Dirigirse a la pestaña de Arduino llamada “Archivo”.
4. Dar clic en “Preferencias”.
5. Dirígete al Gestor de URLs Adicionales de Tarjetas:
6. En la casilla pegar la URL. Si hay otra URL colocar una coma al final, dar un espacio y pegar la
URL.
7. Dar clic en Ok.
8. Ir a la pestaña de Arduino llamada “Herramientas”
9. Dar clic en “Placa:” y después a “Gestor de tarjetas…”
10. Saldrá una ventana, buscar las placas “esp32 by Espressif Systems” e instalarlas.
Para comprobar la instalación de las tarjetas ESP32 en Arduino IDE y cargar códigos a la placa
realiza lo siguiente:
1. Ir a la pestaña de Arduino llamada “Herramientas”
2. Dar clic en “Placa:”
3. Seleccionar ESP32 Arduino y buscar la placa “DOIT ESP32 DEVKIT V1”
4. También puedes elegir las placas: NodeMCU-32S, Adafruit ESP32 Feather ó ESP32 Dev
Module
5. Después conectar la placa al PC.
6. Ir nuevamente a “Herramientas” y seleccionar el puerto COM que le asigno la PC a la placa.
7. Carga el siguiente código para comprobar que todo salió bien. El código es un blink en el Led
que incorpora la placa que está asignado al pin 2 del ESP32.
8.

Código Blink – Hola mundo en ESP32:

void setup() {
// inicializa el pin digital 2 como salida
pinMode(2, OUTPUT);
}
void loop() {
digitalWrite(2, HIGH); // Enciende el LED
delay(1000); // Espera un segundo
digitalWrite(2, LOW); // Apaga el LED
delay(1000); // Espera un segundo
}

Nota: Si el programa no carga directamente a la placa tendrás que poner en modo de

programación la placa antes de cargar el código, para poner en modo de programación realizar lo
siguiente: Presionar el botón de “BOOT” cuando se esté subiendo el código ya que comienza el
 proceso de carga dejar de oprimir el botón, este proceso lo tendrás que llevar acabo cada que
subas un sketch al ESP32.
/*****************************************************************************/
NFC con DeepSeek: [Link]
f745cb993016
La programación del módulo NFC V3 (o cualquier módulo NFC compatible) con un Arduino
Nano o UNO es relativamente sencilla utilizando la librería adecuada. A continuación, se
muestran los pasos básicos para configurar y programar un módulo NFC con Arduino:
Materiales necesarios:
1. 1) Arduino Nano o UNO.
2. 2) Módulo NFC V3 (por ejemplo, el PN532).
3. 3) Cables de conexión (jumpers).
4) Etiquetas NFC (para pruebas).
Conexiones típicas (para PN532):
El módulo NFC V3 suele comunicarse mediante I2C, SPI o UART. Aquí hay un ejemplo de
conexión para I2C (el más común):
 VCC del módulo NFC → 3,3 V o 5 V de Arduino (dependiendo del módulo).
 GND del módulo NFC → GND de Arduino.
 SDA del módulo NFC → A4 (SDA) de Arduino.
 SCL del módulo NFC → A5 (SCL) de Arduino.
Instalación de la librería:
Utilizar la librería Adafruit PN532 para facilitar la programación. Puede instalarse desde el
Gestor de Librerías del IDE de Arduino:
1. Abrir el IDE del Arduino.
2. Ir a Herramientas > Gestor de Librerías.
3. Buscar Adafruit PN532 e instálala.
Código básico para leer una etiqueta NFC:
Aquí hay un ejemplo de código (cpp) para leer el UID de una etiqueta NFC:
#include <Wire.h>
#include <Adafruit_PN532.h>

// Configuración para trabajar con I2C

#define PN532_IRQ (2)
#define PN532_RESET (3) // No es necesario en algunos módulos
Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET);

void setup() {
[Link](115200);
[Link]("Iniciando módulo NFC...");

[Link]();
uint32_t versiondata = [Link]();
if (!versiondata) {
[Link]("No se encontró el módulo PN532. Verifica las conexiones.");
while (1); // Detiene el programa
}

[Link]("Chip encontrado: PN5");

[Link]((versiondata >> 24) & 0xFF, HEX); // Imprime la Versión del chip
[Link]("Firmware versión: ");
 [Link]((versiondata >> 16) & 0xFF, DEC);
[Link]('.');
[Link]((versiondata >> 8) & 0xFF, DEC); // Imprime

// Configura el módulo para leer etiquetas

[Link]();
[Link]("Esperando una etiqueta NFC...");
}

void loop() {
uint8_t success;
uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 }; // Buffer para almacenar el UID
uint8_t uidLength; // Longitud del UID

// Intenta leer una etiqueta

success = [Link](PN532_MIFARE_ISO14443A, uid, &uidLength);

if (success) {
[Link]("Etiqueta detectada!");
[Link]("UID: ");
for (uint8_t i = 0; i < uidLength; i++) { // Imprime la identificación de la etiq.
[Link](" 0x"); [Link](uid[i], HEX);
}
[Link]();
delay(1000); // Espera 1 segundo antes de leer otra etiqueta
}
}

Explicación del código:

1. Inicialización del módulo NFC: Se configura el módulo y se verifica que esté conectado
correctamente.
2. Lectura de etiquetas: El módulo espera a detectar una etiqueta NFC y, cuando la encuentra,
imprime su UID en el monitor serial.
3. UID: El UID es un identificador único de cada etiqueta NFC.
Pruebas:
1. Conecta el módulo NFC a tu Arduino.
2. Sube el código a tu Arduino Nano o UNO.
3. Abre el Monitor Serial (ajusta la velocidad a 115200 baudios).
4. Acerca una etiqueta NFC al módulo y verás que se imprime su UID.
Posibles mejoras:
 Escribir en una etiqueta NFC: Puedes usar la función nfc.ntag2xx_WritePage() para escribir
datos en una etiqueta compatible.
 Comunicación con otros dispositivos: El módulo NFC también puede comunicarse con
smartphones u otros dispositivos NFC.
Para modificar el programa y activar un pin del Arduino (ejemplo: encender un LED o activar un
relé) cuando una tarjeta NFC esté incluida en un archivo de permisos, puedes seguir estos pasos:
Pasos a seguir:
1. Definir una lista de UIDs permitidos: Almacena los UIDs de las tarjetas autorizadas en
un array.
2. Comparar el UID leído: Cuando se detecte una tarjeta, compara su UID con la lista de
UIDs permitidos.
 3. Activar un pin: Si el UID está en la lista, activa un pin digital (por ejemplo, para
encender un LED verde o activar un relé); si no está en lista puede encenderse un LED
rojo, etc.
#include <Wire.h>
#include <Adafruit_PN532.h>

// Configuración para I2C

#define PN532_IRQ (2)
#define PN532_RESET (3) // No es necesario en algunos módulos.
Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET);

// Pin para activar el acceso (por ejemplo, un LED o relé).

#define ACCESS_PIN 8 // Acá se pondría el LED verde.

// Lista de UIDs permitidos (cada UID es un array de bytes).

uint8_t allowedUIDs[][7] = {
{0x12, 0x34, 0x56, 0x78}, // Ejemplo de UID 1
{0xAB, 0xCD, 0xEF, 0x12}, // Ejemplo de UID 2
// ……. Añade aquí más UIDs
};
uint8_t allowedUIDsLength = sizeof(allowedUIDs) / sizeof(allowedUIDs[0]);

void setup() {
[Link](115200); // Activar la comunicación Arduino-PC (o LapTop)
[Link]("Iniciando módulo NFC...");

// Configura el pin de acceso (LED verde) como salida

pinMode(ACCESS_PIN, OUTPUT);
digitalWrite(ACCESS_PIN, LOW); // Asegura que el pin esté apagado al inicio

[Link]();
uint32_t versiondata = [Link]();
if (!versiondata) {
[Link]("No se encontró el módulo PN532. Verifica las conexiones.");
while (1); // Detiene el programa
}
// Se encontró el Módulo PN532 (V3?):
[Link]("Chip encontrado: PN5");
[Link]((versiondata >> 24) & 0xFF, HEX);
[Link]("Firmware versión: ");
[Link]((versiondata >> 16) & 0xFF, DEC);
[Link]('.');
[Link]((versiondata >> 8) & 0xFF, DEC);

// Configura el módulo para leer etiquetas:

[Link]();
[Link]("Esperando una etiqueta NFC...");
}

void loop() {
uint8_t success;
uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 }; // Buffer para almacenar el UID
uint8_t uidLength; // Longitud del UID

// Intentar leer una etiqueta:

success = [Link](PN532_MIFARE_ISO14443A, uid, &uidLength);

if (success) { // Si hay una etiqueta, tarjeta o tag presente:

[Link]("Etiqueta detectada!");
[Link]("UID: ");
for (uint8_t i = 0; i < uidLength; i++) {
[Link](" 0x"); [Link](uid[i], HEX);
 }
[Link]();

// Verifica si el UID está en la lista de permitidos:

if (isUIDAllowed(uid, uidLength)) { // Ir a ver si la UID está habilitada
[Link]("Acceso concedido."); // acá está habilitada
digitalWrite(ACCESS_PIN, HIGH); // Activa el pin de acceso
delay(5000); // Mantener el acceso por 5 segundos
digitalWrite(ACCESS_PIN, LOW); // Desactiva el pin de acceso
} else { // Acá, si la UID no está habilitada:
[Link]("Acceso denegado."); // Aquí puede prenderse un LED rojo
}

delay(1000); // Espera 1 segundo antes de leer otra etiqueta

}
}

// Función para verificar si el UID está en la lista de permitidos:

bool isUIDAllowed(uint8_t *uid, uint8_t uidLength) {
for (uint8_t i = 0; i < allowedUIDsLength; i++) {
bool match = true;
for (uint8_t j = 0; j < uidLength; j++) { // Verificar si la NFC está habilitada
if (uid[j] != allowedUIDs[i][j]) {
match = false; // No está habilitada: salir del “for”
break;
}
}
if (match) {
return true; // El UID está en la lista de permitidos
}
}
return false; // El UID no está en la lista de permitidos
}

Modificar el primer programa para escribir datos en una etiqueta NFC; puede usarse la librería
Adafruit PN532 para escribir en etiquetas compatibles, como las MIFARE Classic o NTAG.
Veamos cómo hacerlo:
#include <Wire.h>
#include <Adafruit_PN532.h>

// Configuración para I2C

#define PN532_IRQ (2)
#define PN532_RESET (3) // No es necesario en algunos módulos
Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET);

void setup() {
[Link](115200); // Conexión Arduino y LapTop o PC
[Link]("Iniciando módulo NFC...");

[Link](); // Activación de interacción Arduino-PN532

uint32_t versiondata = [Link](); // Hay PN532 conectado?
if (!versiondata) { // no: indicarlo y detener la ejecución
[Link]("No se encontró el módulo PN532. Verifica las conexiones.");
while (1); // Detiene el programa
}

[Link]("Chip encontrado: PN5"); // si: avisar e identificarlo

[Link]((versiondata >> 24) & 0xFF, HEX);
[Link]("Firmware versión: ");
[Link]((versiondata >> 16) & 0xFF, DEC);
[Link]('.');
[Link]((versiondata >> 8) & 0xFF, DEC);
 // Configura el módulo para leer y escribir etiquetas:
[Link]();
[Link]("Esperando una etiqueta NFC para escribir...");
}

void loop() {
uint8_t success;
uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 }; // Buffer para almacenar el UID
uint8_t uidLength; // Longitud del UID

// Intenta leer una etiqueta, tarjeta o Tag (UID):

success = [Link](PN532_MIFARE_ISO14443A, uid, &uidLength);

if (success) { // UID detectada y leída

[Link]("Etiqueta detectada!");
[Link]("UID: ");
for (uint8_t i = 0; i < uidLength; i++) { // Imprimir identificación de Etiqueta
[Link](" 0x"); [Link](uid[i], HEX);
}
[Link]();

// Escribir datos en la etiqueta UID

if (writeToTag(uid, uidLength)) {
[Link]("Escritura exitosa.");
} else {
[Link]("Error al escribir en la etiqueta.");
}

delay(2000); // Espera 2 segundos antes de intentar otra escritura

}
}

// Función para escribir datos en la etiqueta NFC

bool writeToTag(uint8_t *uid, uint8_t uidLength) {
// Verifica si la etiqueta es compatible (MIFARE Classic 1 k)
if (uidLength != 4) {
[Link]("Esta etiqueta no es compatible con MIFARE Classic.");
return false;
}

// Autentica el bloque (necesario para MIFARE Classic) x—x UID con 16 Sectores, 4 Bloques/Sector y 16 bytes/Bloque
uint8_t blockNumber = 4; // Bloque donde se escribirá (evita bloques reservados)
uint8_t key[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; // Clave por defecto
if (!nfc.mifareclassic_AuthenticateBlock(uid, uidLength, blockNumber, 1, key)) {
[Link]("Error de autenticación.");
return false;
}

// Datos a escribir (16 bytes por bloque)

uint8_t data[] = { 'H', 'o', 'l', 'a', ' ', 'N', 'F', 'C', '!', 0, 0, 0, 0, 0, 0, 0 };

// Escribe en el bloque
if (!nfc.mifareclassic_WriteDataBlock(blockNumber, data)) { // Si no hay error: escribe “data”
[Link]("Error al escribir en el bloque.");
return false;
}

[Link]("Datos escritos en el bloque ");

[Link](blockNumber);
[Link](": ");
for (uint8_t i = 0; i < 16; i++) {
[Link]((char)data[i]);
 }
[Link]();

return true;
}

Explicación del código:

1. Lectura del UID: El programa primero detecta la etiqueta NFC y lee su UID.
2. Autenticación: Para escribir en una etiqueta MIFARE Classic, es necesario autenticar el
bloque usando una clave (por defecto, 0xFFFFFFFFFFFF).
3. Escritura de datos: Se escribe un mensaje (en este caso, "Hola NFC!") en un bloque
específico de la etiqueta.
4. Comprobación: Si la escritura es exitosa, se muestra un mensaje en el monitor serial.
Consideraciones:
 Tipo de etiqueta: Este código está diseñado para etiquetas MIFARE Classic 1 k. Si usas
otro tipo de etiqueta (como NTAG), necesitarás modificar el código para usar las
funciones adecuadas (por ejemplo, ntag2xx_WritePage para NTAG).
 Bloques reservados: En las etiquetas MIFARE Classic, algunos bloques están reservados
(por ejemplo, el bloque 0 contiene el UID). Evita escribir en estos bloques.
 Clave de autenticación: Asegúrate de usar la clave correcta para autenticar la etiqueta.
La clave por defecto es 0xFFFFFFFFFFFF.
Cómo usar:
1. Conecta el módulo NFC al Arduino.
2. Sube el código a tu Arduino.
3. Abre el Monitor Serial (ajusta la velocidad a 115200 baudios).
4. Acerca una etiqueta NFC al módulo:
o El programa detectará la etiqueta y escribirá el mensaje "Hola NFC" en el
bloque 4.
o Verás un mensaje de confirmación en el monitor serial.

Para leer una etiqueta NFC después de escribir, puedes agregar una función que lea el bloque
donde se escribieron los datos y verifique que la información se haya guardado correctamente. A
continuación, te muestro cómo modificar el código anterior para incluir esta funcionalidad:
#include <Wire.h>
#include <Adafruit_PN532.h>

// Configuración para I2C

#define PN532_IRQ (2)
#define PN532_RESET (3) // No es necesario en algunos módulos
Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET);

void setup() {
[Link](115200);
[Link]("Iniciando módulo NFC...");

[Link]();
uint32_t versiondata = [Link]();
if (!versiondata) {
[Link]("No se encontró el módulo PN532. Verifica las conexiones.");
while (1); // Detiene el programa
}

[Link]("Chip encontrado: PN5");

 [Link]((versiondata >> 24) & 0xFF, HEX);
[Link]("Firmware versión: ");
[Link]((versiondata >> 16) & 0xFF, DEC);
[Link]('.');
[Link]((versiondata >> 8) & 0xFF, DEC);

// Configura el módulo para leer y escribir etiquetas

[Link]();
[Link]("Esperando una etiqueta NFC para escribir...");
}

void loop() {
uint8_t success;
uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 }; // Buffer para almacenar el UID
uint8_t uidLength; // Longitud del UID

// Intenta leer una etiqueta:

success = [Link](PN532_MIFARE_ISO14443A, uid, &uidLength);

if (success) {
[Link]("Etiqueta detectada!");
[Link]("UID: ");
for (uint8_t i = 0; i < uidLength; i++) { // Imprime la identificación de la etiqueta
[Link](" 0x"); [Link](uid[i], HEX);
}
[Link]();

// Escribir datos en la etiqueta NFC

if (writeToTag(uid, uidLength)) {
[Link]("Escritura exitosa.");
// Leer el bloque después de escribir
readFromTag(uid, uidLength);
} else {
[Link]("Error al escribir en la etiqueta.");
}

delay(2000); // Espera 2 segundos antes de intentar otra escritura

}
}

// Función para escribir datos en un bloque de la etiqueta NFC

bool writeToTag(uint8_t *uid, uint8_t uidLength) {
// Verifica si la etiqueta es compatible (MIFARE Classic 1K)
if (uidLength != 4) {
[Link]("Esta etiqueta no es compatible con MIFARE Classic.");
return false;
}
// Autentica el bloque (necesario para MIFARE Classic)
uint8_t blockNumber = 4; // Bloque donde se escribirá (evita bloques reservados)
uint8_t key[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; // Clave por defecto
if (!nfc.mifareclassic_AuthenticateBlock(uid, uidLength, blockNumber, 1, key)) {
[Link]("Error de autenticación.");
return false;
}
// Datos a escribir (16 bytes por bloque)
uint8_t data[] = { 'H', 'o', 'l', 'a', ' ', 'N', 'F', 'C', '!', 0, 0, 0, 0, 0, 0, 0 };
// Escribe en el bloque
if (!nfc.mifareclassic_WriteDataBlock(blockNumber, data)) {
[Link]("Error al escribir en el bloque.");
return false;
}
// Mostrar por Cónsola
 [Link]("Datos escritos en el bloque ");
[Link](blockNumber);
[Link](": ");
for (uint8_t i = 0; i < 16; i++) { // Escribe los 16 octetos del Bloque
[Link]((char)data[i]);
}
[Link]();
return true;
}

// Función para leer datos de la etiqueta NFC

void readFromTag(uint8_t *uid, uint8_t uidLength) {
// Verifica si la etiqueta es compatible (MIFARE Classic 1K)
if (uidLength != 4) {
[Link]("Esta etiqueta no es compatible con MIFARE Classic.");
return;
}
// Autentica el bloque (necesario para MIFARE Classic)
uint8_t blockNumber = 4; // Bloque que se escribió
uint8_t key[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; // Clave por defecto
if (!nfc.mifareclassic_AuthenticateBlock(uid, uidLength, blockNumber, 1, key)) {
[Link]("Error de autenticación.");
return;
}
// Buffer para almacenar los datos leídos
uint8_t data[16];

// Lee el bloque
if (!nfc.mifareclassic_ReadDataBlock(blockNumber, data)) {
[Link]("Error al leer el bloque.");
return;
}

[Link]("Datos leídos del bloque ");

[Link](blockNumber);
[Link](": ");
for (uint8_t i = 0; i < 16; i++) { // Imprimir los 16 octetos del Bloque 4
[Link]((char)data[i]);
}
[Link]();
}

Explicación del código:

1. Escritura de datos: La función writeToTag escribe el mensaje "Hola NFC" en el bloque
4 de la etiqueta.
2. Lectura de datos: La función readFromTag lee el bloque 4 después de la escritura y
muestra los datos en el monitor serial.
3. Autenticación: Ambas funciones (escribir y leer) requieren autenticar el bloque usando la
clave por defecto (0xFFFFFFFFFFFF).
4. Verificación: Después de escribir, el programa lee el bloque para asegurarse de que los
datos se hayan guardado correctamente.
Cómo usar:
1. Conecta el módulo NFC a tu Arduino.
2. Sube el código a tu Arduino.
3. Abre el Monitor Serial (ajusta la velocidad a 115200 baudios).
4. Acerca una etiqueta NFC al módulo:
 El programa escribirá "Hola NFC" en el bloque 4.
  Luego, leerá el bloque 4 y mostrará los datos en el monitor serial.
Impresión del programa:
Iniciando módulo NFC...
Chip encontrado: PN532
Firmware versión: 1.6
Esperando una etiqueta NFC para escribir...
Etiqueta detectada!
UID: 0x12 0x34 0x56 0x78
Datos escritos en el bloque 4: Hola NFC!
Escritura exitosa.
Datos leídos del bloque 4: Hola NFC!
Pasos para Excel:
1. Programar el Arduino para enviar datos por el puerto serial:
o El Arduino envía los datos en formato CSV (por ejemplo: UID,Fecha,Hora).
void setup() {
[Link](115200);
}
void loop() {
// Simular la lectura de una NFC y obtener la hora
String uid = "12345678"; // Reemplaza con el UID leído
String fecha = "2023-10-15"; // Reemplaza con la fecha actual
String hora = "[Link]"; // Reemplaza con la hora actual
// Enviar los datos por el puerto serial
[Link](uid + "," + fecha + "," + hora);
delay(5000); // Espera 5 segundos antes de enviar otro dato
}

2. Capturar los datos en la computadora:

o Usa un programa como CoolTerm o Tera Term para capturar los datos del
puerto serial y guardarlos en un archivo CSV.
o Abre el archivo CSV en Excel.
3. Automatizar con Python:
o Puedes usar un script en Python para leer el puerto serial y escribir los datos en un
archivo Excel (usando la librería pandas o openpyxl).
******************************************************************************
DeepSeek: conexión de una NFC Module V3 a un ESP32:
Conectar un ESP32 a un módulo NFC532 V3 y programarlo para leer y escribir en etiquetas NFC
es un proceso relativamente sencillo. A continuación, veamos cómo hacerlo paso a paso.
Conexión entre el ESP32 y el NFC532 Module V3
El módulo NFC532 V3 generalmente utiliza comunicación I 2C o SPI. Para este ejemplo,
asumiremos utilizar la comunicación I2C, que es más común y sencilla de implementar.
Conexiones:
 Vcc del NFC532 -> 3,3 V del ESP32
 GND del NFC532 -> GND del ESP32
 SDA del NFC532 -> GPIO 21 del ESP32 (SDA en I2C)
SCL del NFC532 -> GPIO 22 del ESP32 (SCL en I2C)
Librería necesaria
Para interactuar con el módulo NFC, puedes utilizar la librería PN532 que es compatible con el ESP32. Puedes
instalarla a través del Library Manager en el IDE de Arduino.

1) Programa de Lectura de una Etiqueta NFC

A continuación, tenemos un ejemplo de cómo leer una etiqueta NFC (cpp):
#include <Wire.h>
#include <PN532_I2C.h>
#include <PN532.h>
#include <NfcAdapter.h>
PN532_I2C pn532_i2c(Wire);
NfcAdapter nfc = NfcAdapter(pn532_i2c);
void setup(void) {
[Link](115200);
[Link]("Inicializando lector NFC...");
[Link]();
}
void loop(void) {
[Link]("\nColoca una etiqueta NFC cerca del lector...");
if ([Link]()) {
NfcTag tag = [Link]();
[Link]("Tag detectado!");
[Link]([Link]());
[Link]("UID: ");
[Link]([Link]());
if ([Link]()) {
NdefMessage message = [Link]();
[Link]("Mensaje NDEF: ");
[Link]();
}
}
delay(5000);
}

2) Programa de Escritura en una Etiqueta NFC

Recordemos para cualquier CI (28 bit), Dirección, telf y telf contacto, que hay 8 tipos de sangre A±, B±, AB±, O±,
enfermedades: cáncer, asma (11), Epoxia, Fibrosis Pulmonar, diabetes (7), hemofilia, anemia, trombocitopenia,
hipotensión, cardiópata (14), insuficiencia renal crónica, diálisis, epilepsia, ACV, Parkinson, polio, amputado,
paraplejia, ciego, sordo, mudo, manco, leucemia, psoriasis, hepatitis B o C o cirrósis, hemorroide, hipo/hiper-
tiroidismo + enfermedad de Addison, Alhzeimer, laberintitis, embarazo, alergia (penicilina, aspirina, menthiolate,
vitamina B, pintura, polvo), consume (anticoagulante, antiagr., insulina, alcohólico, drogadicto), depresión,
esquizofrenia, bipolar, VHI/SIDA, tuberculosis, cirugías previas (Bypass, prótesis válvula, marcapasos), úlcera
péptica o gástrica, gastritis, prostatitis, hernia (inguinal, umbilical, vertebral) ¿cuál otra para incluir en la NFC?
Ahora, veamos un ejemplo de cómo escribir en una etiqueta NFC (cpp):
#include <Wire.h>
#include <PN532_I2C.h>
#include <PN532.h>
#include <NfcAdapter.h>
PN532_I2C pn532_i2c(Wire);
NfcAdapter nfc = NfcAdapter(pn532_i2c);
void setup(void) {
 [Link](115200);
[Link]("Inicializando lector NFC...");
[Link]();
}
void loop(void) {
[Link]("\nColoca una etiqueta NFC cerca del lector para escribir...");
if ([Link]()) {
NdefMessage message = NdefMessage();
[Link]("Hola, esto es una prueba de escritura NFC!");
bool success = [Link](message);
if (success) {
[Link]("Escritura exitosa!");
} else {
[Link]("Error al escribir en la etiqueta.");
}
}
delay(5000);
}
Explicación del Código
1. Inicialización: En el setup(), se inicializa la comunicación I2C y el módulo NFC.
2. Lectura: En el loop(), se verifica si hay una etiqueta NFC presente. Si se detecta una, se lee su UID y, si contiene un
mensaje NDEF, se imprime en el monitor serial.
3. Escritura: En el loop(), se verifica si hay una etiqueta NFC presente. Si se detecta una, se escribe un mensaje NDEF
en la etiqueta.
Consideraciones
 Voltaje: Asegúrate de que el módulo NFC532 V3 esté conectado a 3.3V, ya que el ESP32 trabaja a ese voltaje y
podrías dañar el módulo si lo conectas a 5V.
 Distancia: La distancia de lectura/escritura de NFC es corta, generalmente de unos pocos centímetros, así que
asegúrate de que la etiqueta esté cerca del módulo.
Con estos pasos y códigos, podemos poder conectar y programar un ESP32 para leer y escribir en etiquetas NFC
utilizando el módulo NFC532 V3.

******************************************************************************
Conectar un Arduino Nano a un módulo NFC V3 y leer/escribir datos es un proceso factible
que sigue una serie de pasos (Ver el archivo DeepSeek_Gemini.doc):
A) Materiales necesarios:
1. Arduino Nano
2. Módulo NFC V3 (por ejemplo, el PN532)
3. Cables de conexión (jumpers)
4. Tarjeta NFC o etiqueta NFC (para pruebas)
B) Conexiones entre el Arduino Nano y el módulo NFC V3:
El módulo NFC V3 (PN532) puede comunicarse con el Arduino Nano mediante I2C, SPI o
UART. Aquí veremos la conexión más común usando I2C:
C) Módulo NFC V3 (PN532) Arduino Nano
VCC 3,3 V o 5 V (dependiendo del módulo)
GND GND
SDA A4 (SDA)
SCL A5 (SCL)
Nota: Algunos módulos NFC V3 funcionan a 3,3 V, así que verifica el voltaje de operación del
módulo antes de conectarlo.
D) Instalación de la librería necesaria:
Para facilitar la comunicación con el módulo NFC, puede usarse la librería Adafruit PN532.
Instálala desde el Gestor de Librerías del IDE de Arduino:
1. Abre el IDE de Arduino.
2. Ve a Herramientas  Gestor de Librerías.
3. Busca Adafruit PN532 e instálala.
E) Código para leer y escribir datos en la NFC:
A continuación, tenemos un ejemplo básico para leer y escribir datos en una tarjeta NFC:
#include <Wire.h>
#include <Adafruit_PN532.h>
#define PN532_IRQ (2)
#define PN532_RESET (3) // No conectado si no se usa
Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET);
void setup() {
[Link](115200);
[Link]("Iniciando módulo NFC...");
[Link]();
uint32_t versiondata = [Link]();
if (!versiondata) {
[Link]("No se encontró el módulo PN532");
while (1); // Detener el programa
}
[Link]("Chip encontrado PN5"); [Link]((versiondata >> 24) & 0xFF, HEX); //
Imprime tipo de PN5xx
[Link]("Firmware versión: "); [Link]((versiondata >> 16) & 0xFF, DEC); //
Imprime su Versión
[Link]('.'); [Link]((versiondata >> 8) & 0xFF, DEC);
[Link](); // Configurar el módulo para leer tarjetas
[Link]("Esperando una tarjeta NFC...");
}
void loop() {
uint8_t success;
uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 }; // Buffer para almacenar el UID
uint8_t uidLength; // Longitud del UID
// Esperar a que se acerque una etiqueta NFC para leerla
success = [Link](PN532_MIFARE_ISO14443A, uid, &uidLength);
if (success) {
[Link]("Tarjeta detectada!");
// Mostrar el UID de la tarjeta
[Link]("UID Length: "); [Link](uidLength, DEC); [Link](" bytes");
[Link]("UID Value: ");
for (uint8_t i = 0; i < uidLength; i++) {
[Link](" 0x"); [Link](uid[i], HEX);
}
[Link]();
 // Escribir datos en la tarjeta NFC ********
uint8_t data[] = { 0x48, 0x65, 0x6C, 0x6C, 0x6F }; // "Hello" en hexadecimal
uint8_t blockNumber = 4; // Bloque donde se escribirá (elige un bloque que
no esté protegido)
success = nfc.mifareclassic_WriteDataBlock(blockNumber, data);
if (success) {
[Link]("Datos escritos correctamente!");
} else {
[Link]("Error al escribir datos.");
}
// Leer datos de un Bloque NFC ********
uint8_t readData[16];
success = nfc.mifareclassic_ReadDataBlock(blockNumber, readData);
if (success) {
[Link]("Datos leídos: ");
for (uint8_t i = 0; i < 16; i++) {
[Link](" 0x"); [Link](readData[i], HEX);
}
[Link]();
} else {
[Link]("Error al leer datos.");
}
delay(2000); // Esperar 2 segundos antes de repetir
}
}

Explicación del código:

1. Inicialización del módulo NFC: Se configura el módulo PN532 y se verifica su correcto
funcionamiento.
2. Detección de tarjetas: El código espera a que una tarjeta NFC se acerque al módulo.
3. Lectura del UID: Se obtiene y muestra el UID de la tarjeta.
4. Escritura de datos: Se escribe un bloque de datos en la tarjeta NFC.
5. Lectura de datos: Se lee el bloque de datos previamente escrito.
Consideraciones adicionales:
 Bloques protegidos: Algunos bloques de la tarjeta NFC pueden estar protegidos contra
escritura. Asegúrate de escribir en bloques que no estén protegidos.
 Tipo de tarjeta: Este código está diseñado para tarjetas MIFARE Classic 1 k. Si usas
otro tipo de tarjeta, es posible que necesites ajustar el código.
Con lo anterior ya puede conectarse el Arduino Nano a un módulo NFC V3 y leer/escribir datos
en tarjetas NFC.
******************************************************************************
La memoria de una tarjeta NFC (por ejemplo, una MIFARE Classic 1 k) está organizada en
bloques y sectores. Cada tarjeta tiene una estructura específica que determina cómo se
almacenan los datos y cómo se protegen. A continuación, se muestra cómo está distribuida la
memoria en una tarjeta NFC típica, como la MIFARE Classic 1 k, que es una de las más
comunes.
Estructura de la memoria en una MIFARE Classic 1 k:
1. Capacidad total: 1 kB (1024 bytes).
2. División en sectores: 16 sectores.
 3. Bloques por sector: 4 bloques.
4. Tamaño de cada bloque: 16 bytes.
En total, hay 64 bloques (16 sectores × 4 bloques) numerados del 0 al 63.
Distribución de los bloques:
1. Bloque 0:
o Contiene los primeros 16 bytes de la memoria.
o Los primeros 4 bytes almacenan el UID (Identificador Único) de la tarjeta.
o Los siguientes 12 bytes pueden contener datos de fabricante y otros datos de solo
lectura.
2. Bloques de datos:
o Los bloques del 1 al 63 se utilizan para almacenar datos.
o Cada sector tiene 3 bloques de datos (por ejemplo, en el sector 0, los bloques 1, 2
y 3 son bloques de datos).
3. Bloques de control (Trailer):
o El último bloque de cada sector (bloque 3, 7, 11, ..., 63) es un bloque de control.
o Este bloque contiene:
 Claves de acceso (Key A y Key B): Se utilizan para autenticar operaciones
de lectura/escritura.
 Bits de control: Determinan los permisos de acceso (lectura, escritura,
incremento, etc.).
Ejemplo de distribución de un sector:
Bloque Contenido
0 Datos (o UID en el sector 0)
1 Datos
2 Datos
3 Bloque de control (Trailer)
Permisos de acceso:
Los permisos de acceso se definen en los bits de control del bloque de control (Trailer). Estos
permisos determinan:
 Si se puede leer o escribir en los bloques de datos.
 Si se requiere autenticación con Key A o Key B.
 Si se permiten operaciones como incremento o decremento (en tarjetas que soportan
estas operaciones).
Ejemplo de uso de la memoria:
Supongamos que queremos almacenar el texto "Hola NFC" en una tarjeta:
1. Convertimos el texto a hexadecimal: 48 6F 6C 61 20 4E 46 43.
2. Elegimos un bloque de datos (por ejemplo, el bloque 4).
3. Escribimos los datos en el bloque 4 usando el código de Arduino.
Consideraciones importantes:
1. Protección de bloques:
o Algunos bloques (como el bloque 0) son de solo lectura.
o Los bloques de control (Trailer) deben manejarse con cuidado, ya que contienen
las claves de acceso.
2. Compatibilidad:
 o La estructura de memoria puede variar según el tipo de tarjeta NFC (por ejemplo,
MIFARE Ultralight, NTAG, etc.).
o Asegúrate de usar la librería y métodos adecuados para el tipo de tarjeta que estás
utilizando.
3. Seguridad:
o Las tarjetas MIFARE Classic tienen vulnerabilidades conocidas en su sistema de
autenticación. Para aplicaciones críticas, considera usar tarjetas más seguras como
las MIFARE DESFire.
******************************************************************************
¿Cuándo activar la comunicación Arduino-PC serie?
La comunicación serie debe activarse al inicio del programa, en la función setup(), ya que es
una configuración que solo necesita realizarse una vez. Luego, puedes enviar mensajes en
cualquier momento durante la ejecución del programa, ya sea en el setup() o en el loop().
Pasos para configurar y usar la comunicación serie:
1. Iniciar la comunicación serie:
o En el setup(), usa la función [Link]() para configurar la velocidad de
comunicación (baud rate). Por ejemplo:
void setup() {
[Link](9600); // Inicia la comunicación serie a 9600 baudios
}
2. Enviar mensajes a la PC:
o Usa la función [Link]() o [Link]() para enviar datos a la PC. Por
ejemplo:
void loop() {
[Link]("Hola, PC!"); // Envía un mensaje a la PC
delay(1000); // Espera 1 segundo antes de repetir
}
3. Leer datos desde la PC (opcional):
o Si necesitas recibir datos desde la PC, usa [Link]() para verificar si
hay datos disponibles y [Link]() para leerlos. Por ejemplo:
void loop() {
if ([Link]() > 0) {
char dato = [Link](); // Lee un byte de datos
[Link]("Recibido: ");
[Link](dato); // Envía el dato de vuelta a la PC
}
}
4. Ejemplo completo:
o Este código envía un mensaje a la PC cada segundo y también está listo para
recibir datos desde la PC:
void setup() {
[Link](9600); // Inicia la comunicación serie a 9600 baudios
[Link]("Arduino Nano listo!"); // Envía un mensaje inicial
}
void loop() {
 // Envía un mensaje a la PC cada segundo
[Link]("Hola, PC!");
delay(1000);
// Lee datos desde la PC (si los hay)
if ([Link]() > 0) {
char dato = [Link](); // Lee un byte de datos
[Link]("Recibido: ");
[Link](dato); // Envía el dato de vuelta a la PC
}
}
¿Cómo ver los mensajes en la PC?
1. Abre el Monitor Serie en el IDE de Arduino (HerramientasMonitor Serie).
2. Asegúrate de que la velocidad de baudios (baud rate) coincida con la configurada en el
código (en este caso, 9600).
3. Verás los mensajes enviados desde el Arduino Nano y podrás enviar datos desde la PC al
Arduino.
Notas importantes:
 La comunicación serie usa los pines D0 (RX) y D1 (TX) del Arduino Nano. No los uses
para otros propósitos si estás utilizando la comunicación serie.
 Si necesitas depurar tu código, la comunicación serie es una herramienta muy útil para
enviar información sobre el estado del programa.
******************************************************************************
Para escribir en una etiqueta NFC utilizando un Arduino Nano y un NFC Module V3 conectado
vía I2C, deben seguirse los pasos:
1. Configurar la comunicación I2C entre el Arduino Nano y el NFC Module V3.
2. Inicializar el módulo NFC y verificar si hay una etiqueta presente.
3. Escribir datos en los sectores permitidos de la etiqueta NFC.
A continuación, veremos un ejemplo de código que realiza estas tareas. Este código utiliza la
librería Adafruit_532.h para manejar la comunicación con el módulo NFC.
Requisitos:
1. Librería Adafruit_PN532:
o Instala la librería Adafruit-PN532 desde el Gestor de Librerías del IDE de
Arduino.
o Ve a Sketch  Incluir Librería  Gestionar Bibliotecas, busca
Adafruit PN532 e instálala.
2. Conexiones I2C:
o Conecta el NFC Module V3 al Arduino Nano de la siguiente manera:
 SDA del NFC Module V3  A4 del Arduino Nano.
 SCL del NFC Module V3  A5 del Arduino Nano.
 VCC del NFC Module V3  3,3V o 5V del Arduino Nano (dependiendo
de la versión del módulo).
 GND del NFC Module V3  GND del Arduino Nano.

Código para escribir en una etiqueta NFC:

#include <Wire.h>
#include <Adafruit_PN532.h>
// Configuración del módulo NFC
#define PN532_IRQ (2) // Pin IRQ (no necesario en I2C, pero debe definirse)
#define PN532_RESET (3) // Pin de reset (no necesario en I2C, pero debe definirse)
// Crea una instancia del objeto PN532
Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET);
void setup() {
[Link](9600);
[Link]("Iniciando módulo NFC...");
// Inicializa el módulo NFC
[Link]();
// Verifica la conexión con el módulo NFC
uint32_t versiondata = [Link]();
if (!versiondata) {
[Link]("No se encontró el módulo PN532. Verifica las conexiones.");
while (1); // Detiene el programa si no se encuentra el módulo
}
// Configura el módulo para leer etiquetas
[Link]();
[Link]("Módulo NFC listo.");
}
void loop() {
[Link]("Selecciona y acerca la etiqueta NFC a escribir...");
// Espera a que se acerque una etiqueta NFC
uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 }; // Buffer para almacenar el UID
uint8_t uidLength; // Longitud del UID
// Intenta leer el UID de la etiqueta
bool success = [Link](PN532_MIFARE_ISO14443A, uid, &uidLength);
if (success) {
[Link]("Etiqueta NFC detectada.");
// Muestra el UID de la etiqueta
[Link]("UID: ");
for (uint8_t i = 0; i < uidLength; i++) {
[Link](uid[i], HEX);
[Link](" ");
}
[Link]();
// Escribe datos en un sector permitido (por ejemplo, sector 1, bloque 4)
uint8_t sector = 1;
uint8_t block = 4;
uint8_t data[16] = { 'H', 'o', 'l', 'a', ' ', 'N', 'F', 'C', '!', 0, 0, 0, 0, 0, 0, 0 }; // Datos a escribir
 // Autentica el bloque antes de escribir:
success = nfc.mifareclassic_AuthenticateBlock(uid, uidLength, block, 1, (uint8_t*)KEY_DEFAULT);
if (success) {
// Tarjeta autenticada: escribe los datos en el bloque
success = nfc.mifareclassic_WriteDataBlock(block, data);
if (success) {
[Link]("Datos escritos correctamente.");
} else {
[Link]("Error al escribir en el bloque.");
}
} else {
[Link]("Error de autenticación.");
}
} else {
[Link]("No se detectó ninguna etiqueta NFC.");
}
delay(2000); // Espera 2 segundos antes de repetir
}
Explicación del código:
1. Inicialización:
o Se inicializa el módulo NFC usando [Link]().
o Se verifica la conexión con el módulo NFC usando [Link]().
o Se configura el módulo para leer etiquetas con [Link]().
2. Detección de etiqueta:
o El programa espera a que se acerque una etiqueta NFC usando
[Link]().
o Si se detecta una etiqueta, se muestra su UID en el Monitor Serie.
3. Escritura de datos:
o Se autentica el bloque donde se desea escribir usando
nfc.mifareclassic_AuthenticateBlock().
o Se escriben los datos en el bloque especificado usando
nfc.mifareclassic_WriteDataBlock().
4. Mensajes de depuración:
o Se imprimen mensajes en el Monitor Serie para indicar el estado del proceso.

Detalles importantes:
 Clave de autenticación:
o En este código, se usa la clave predeterminada KEY_DEFAULT = {0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF}.
o Si tu etiqueta usa una clave diferente, debes cambiarla en la función
nfc.mifareclassic_AuthenticateBlock().
 Sectores y bloques:
o Las etiquetas Mifare Classic tienen 16 sectores, cada uno con 4 bloques.
o El bloque 0 de cada sector contiene la clave de acceso y los permisos.
o Solo se pueden escribir datos en los bloques de datos (bloques 1, 2 y 3 de cada
sector).
  Compatibilidad:
o Este código está diseñado para etiquetas Mifare Classic 1K (las más comunes). Si
usas otro tipo de etiqueta, asegúrate de que sea compatible con el módulo PN532.
Prueba:
1. Carga el código en tu Arduino Nano.
2. Abre el Monitor Serie para ver los mensajes.
3. Acerca una etiqueta NFC al módulo y verifica que los datos se escriban correctamente.
Conexiones:
 NFC Module V3:
o SDA -> A4 (Arduino Nano).
o SCL -> A5 (Arduino Nano).
o VCC -> 3.3V o 5V (dependiendo de la versión del módulo).
o GND -> GND.

Borrar: [Link]
Si el programa anterior no se arregla: Borrar también…!
******************************************************************************
El error 'keyDefault' was not declared in this scope indica que el compilador no reconoce la
constante keyDefault, o la constante KEY_DEFAULT = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF}. Esto puede deberse a que la versión de la librería Adafruit_PN532 que se utiliza no
define keyDefault, o bien, no la estás incluyendo correctamente.
Vamos a resolver este problema paso a paso:
1. Verifica la versión de la librería Adafruit_PN532
La constante keyDefault está definida en versiones recientes de la librería Adafruit_PN532. Si
estás utilizando una versión antigua, es posible que no esté disponible.
¿Cómo verificar la versión de la librería?
1. Abre el IDE de Arduino.
2. Ve a Sketch  Incluir Librería  Gestionar Bibliotecas.
3. Busca Adafruit PN532 y verifica la versión instalada.
4. Si la versión es antigua, actualízala a la más reciente.
2. Define keyDefault manualmente
Si la librería no puede actualizarse o si keyDefault no está definida en tu versión, puedes
declararla manualmente en tu código. Aquí se muestra cómo hacerlo:
const uint8_t keyDefault[6] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
Luego, puedes usarla en la función mifareclassic_AuthenticateBlock sin problemas.
3. Código corregido con keyDefault definida manualmente
Aquí te dejo el código completo con keyDefault definida manualmente:
#include <Wire.h>
#include <Adafruit_PN532.h>
// Define la clave de autenticación predeterminada
const uint8_t keyDefault[6] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
// Configuración del módulo NFC
#define PN532_IRQ (2)
#define PN532_RESET (3) // No es necesario si no estás usando el pin de reset
// Crea una instancia del objeto PN532
Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET);
void setup() {
[Link](9600);
[Link]("Iniciando módulo NFC...");
// Inicializa el módulo NFC
[Link]();
// Verifica la conexión con el módulo NFC
uint32_t versiondata = [Link]();
if (!versiondata) {
[Link]("No se encontró el módulo PN532. Verifica las conexiones.");
while (1); // Detiene el programa si no se encuentra el módulo
}
// Configura el módulo para leer etiquetas
[Link]();
[Link]("Módulo NFC listo.");
}
void loop() {
[Link]("Acerca una etiqueta NFC para escribir...");
// Espera a que se acerque una etiqueta NFC
uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 }; // Buffer para almacenar el UID
uint8_t uidLength; // Longitud del UID
// Intenta leer el UID de la etiqueta
bool success = [Link](PN532_MIFARE_ISO14443A, uid, &uidLength);
if (success) {
[Link]("Etiqueta NFC detectada.");
// Muestra el UID de la etiqueta
[Link]("UID: ");
for (uint8_t i = 0; i < uidLength; i++) {
[Link](uid[i], HEX);
[Link](" ");
}
[Link]();
// Escribe datos en un sector permitido (por ejemplo, sector 1, bloque 4)
uint8_t sector = 1;
uint8_t block = 4;
uint8_t data[16] = { 'H', 'o', 'l', 'a', ' ', 'N', 'F', 'C', '!', 0, 0, 0, 0, 0, 0, 0 };
// Autentica el bloque antes de escribir
success = nfc.mifareclassic_AuthenticateBlock(uid, uidLength, block, 1, keyDefault);
if (success) {
 // Escribe los datos en el bloque
success = nfc.mifareclassic_WriteDataBlock(block, data);
if (success) {
[Link]("Datos escritos correctamente.");
} else {
[Link]("Error al escribir en el bloque.");
}
} else {
[Link]("Error de autenticación.");
}
} else {
[Link]("No se detectó ninguna etiqueta NFC.");
}
delay(2000); // Espera 2 segundos antes de repetir
}
4. Alternativa: Usar un array anónimo
Si prefieres no definir keyDefault, puedes pasar la clave directamente como un array anónimo en
la función mifareclassic_AuthenticateBlock:
success = nfc.mifareclassic_AuthenticateBlock(uid, uidLength, block, 1, (uint8_t[]){ 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF });
5. ¿Por qué no funciona keyDefault en mi versión de la librería?
Es posible que la versión de la librería Adafruit_PN532 que estás utilizando no incluya la
definición de keyDefault. Esto puede deberse a:
 Una versión antigua de la librería.
 Una modificación en la librería que eliminó keyDefault.
En cualquier caso, definir keyDefault manualmente es una solución rápida y efectiva.
Resumen:
 Define keyDefault manualmente si no está disponible en tu versión de la librería.
 Actualiza la librería Adafruit_PN532 si es posible.
 Usa un array anónimo como alternativa
******************************************************************************
Se tiene un Arduino Nano conectado, vía I2C, a una NFC MODULE V3 para leer tarjetas PN532
de 1k Classic; también está conectado a un PC para recibir órdenes de un Operador. La
comunicación y control de las tarjetas se realiza con la librería Adafruit. La idea es hacer un
programa que: 1) Lea la UID de una tarjeta y la muestre, 2) Escriba, en la tarjeta, en el Sector y
Bloque indicados por el Operador exceptuando en el Sector de identificación, 3) Permita, ó no, el
acceso de la tarjeta leída si está autorizada; si permite el acceso debe activar el pin 4 que
manejará un LED verde y un relé, si no la tarjeta no está autorizada debe encender un LED rojo
en el pin 8.
¿Cómo modificarías el programa anterior para que cumpla con esos requerimientos antes
descritos?
Para cumplir con los requerimientos que anteriores, se modifica el programa anterior para que:
1. Lea la UID de una tarjeta y la muestre.
 2. Escriba en la tarjeta en el Sector y Bloque indicados por el Operador (exceptuando el
Sector de identificación).
3. Permita o no el acceso dependiendo de si la tarjeta está autorizada, activando un LED
verde y un relé en el pin 4 si está autorizada, o un LED rojo en el pin 8 si no lo está.
Aquí está el programa modificado:
Código Modificado (Versión V2):
#include <Wire.h> // Librería para comunicación I2C
#include <Adafruit_PN532.h> // Librería Adafruit para el PN532
// Pines para el módulo PN532 (IRQ y RESET no son necesarios en I2C)
#define PN532_IRQ (2)
#define PN532_RESET (3) // No conectado por hardware
// Inicializar el módulo NFC
Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET);
const uint8_t keyDefault[6] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; // Clave por Defecto
// Lista de UIDs autorizados (modificable)
const uint8_t authorizedUIDs[][7] = {
{0x00, 0x00, 0x00, 0x94, 0xBF, 0x58, 0xAF}, // UID de Metro SUVE
{0x00, 0X00, 0X00, 0x74, 0xF3, 0x32, 0x5F}, // UID de Azul Claro
{0x00, 0x00, 0x00, 0xD1, 0x70, 0x67, 0x4C} // UID de Tarjeta
};
const int numAuthorizedUIDs = 3; // Número de UIDs autorizados
// Pines para indicadores de acceso
const uint8_t ledVerde = 4; // LED verde para acceso permitido en D4 (y relé)
const uint8_t ledRojo = 8; // LED rojo para acceso denegado en D8
void setup() {
[Link](9600);
[Link]("Iniciando sistema NFC...");
// Inicializar el módulo NFC
[Link]();
uint32_t versiondata = [Link]();
if (!versiondata) {
[Link]("No se encontró el módulo PN532. Verifica la conexión.");
while (1); // Detener el programa si no se encuentra el módulo
}
[Link]("Chip PN532 encontrado. Versión: ");
[Link](versiondata, HEX);
// Configurar el módulo NFC
[Link]();
// Configurar pines de los LEDs
pinMode(ledVerde, OUTPUT);
pinMode(ledRojo, OUTPUT);
digitalWrite(ledVerde, LOW);
digitalWrite(ledRojo, LOW);
}

void loop() {
[Link]("\nEsperando una tarjeta NFC...");
// Esperar a que una tarjeta NFC esté presente
uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 }; // Buffer para almacenar el UID
uint8_t uidLength; // Longitud del UID
if ([Link](PN532_MIFARE_ISO14443A, uid, &uidLength)) {
[Link]("Tarjeta NFC detectada.");
// Mostrar menú de opciones
mostrarMenu();
// Leer la opción seleccionada por el usuario
int opcion = leerOpcion();
switch (opcion) {
case 1:
leerTarjeta(uid, uidLength); // Leer UID de la tarjeta
break;
case 2:
escribirTarjeta(uid, uidLength); // Escribir en la tarjeta
break;
case 3:
verificarAcceso(uid, uidLength); // Verificar acceso
break;
case 4:
[Link]("Finalizando programa...");
while (1); // Detener el programa
break;
default:
[Link]("Opción no válida.");
break;
}
}
}
// Función para mostrar el menú de opciones
void mostrarMenu() {
[Link]("\nSelecciona una opción:");
[Link]("1. Leer UID de la tarjeta.");
[Link]("2. Escribir datos en la tarjeta.");
[Link]("3. Verificar acceso.");
[Link]("4. Finalizar programa.");
[Link]("Ingresa el número de la opción deseada:");
}
// Función para leer la opción seleccionada por el usuario
int leerOpcion() {
 while (![Link]()); // Esperar a que el usuario ingrese una opción
int opcion = [Link]();
while (opcion < 1 || opcion > 4) {
[Link]("Opción no válida. Intenta de nuevo.");
while (![Link]());
opcion = [Link]();
}
[Link]("Opción seleccionada: ");
[Link](opcion);
return opcion;
}
// Función para leer la UID de la tarjeta NFC
void leerTarjeta(uint8_t *uid, uint8_t uidLength) {
[Link]("Leyendo UID de la tarjeta...");
// Mostrar el UID de la tarjeta
[Link]("UID de la tarjeta: ");
for (uint8_t i = 0; i < uidLength; i++) {
[Link](uid[i], HEX);
[Link](" ");
}
[Link]();
}
// Función para escribir datos en la tarjeta NFC
void escribirTarjeta(uint8_t *uid, uint8_t uidLength) {
[Link]("Escribiendo datos en la tarjeta...");
// Solicitar al operador el sector y bloque
[Link]("Ingresa el número de sector (0-15):");
while (![Link]());
uint8_t sector = [Link]();
[Link]("Sector seleccionado: ");
[Link](sector);
[Link]("Ingresa el número de bloque (0-3):");
while (![Link]());
uint8_t block = [Link]();
[Link]("Bloque seleccionado: ");
[Link](block);
// Verificar que no se intente escribir en el sector de identificación (sector 0)
if (sector == 0) {
[Link]("Error: No se puede escribir en el sector de identificación.");
return;
}
// Solicitar los datos a escribir
[Link]("Ingresa los datos a escribir (16 bytes en formato hexadecimal, separados por
espacios):");
 while (![Link]());
uint8_t data[16];
for (uint8_t i = 0; i < 16; i++) {
data[i] = (uint8_t)strtol([Link](' ').c_str(), NULL, 16);
}
// Autenticar el bloque antes de escribir
bool success = nfc.mifareclassic_AuthenticateBlock(uid, uidLength, block, 1, keyDefault);
if (success) {
// Escribir los datos en el bloque
success = nfc.mifareclassic_WriteDataBlock(block, data);
if (success) {
[Link]("Datos escritos correctamente.");
} else {
[Link]("Error al escribir en el bloque.");
}
} else {
[Link]("Error de autenticación.");
}
}
// Función para verificar el acceso
void verificarAcceso(uint8_t *uid, uint8_t uidLength) {
[Link]("Verificando acceso...");
// Comparar el UID de la tarjeta con la lista de UIDs autorizados
bool accesoPermitido = false;
for (int i = 0; i < numAuthorizedUIDs; i++) {
if (memcmp(uid, authorizedUIDs[i], uidLength) == 0) {
accesoPermitido = true;
break;
}
}
// Mostrar resultado y controlar los LEDs
if (accesoPermitido) {
[Link]("Acceso permitido.");
digitalWrite(ledVerde, HIGH); // Activar LED verde y relé
digitalWrite(ledRojo, LOW);
} else {
[Link]("Acceso denegado.");
digitalWrite(ledVerde, LOW);
digitalWrite(ledRojo, HIGH); // Activar LED rojo
}
delay(3000); // Espera 3 segundos antes de apagar los LEDs
digitalWrite(ledVerde, LOW);
digitalWrite(ledRojo, LOW);
}
Explicación de las modificaciones
1. Lectura de la UID:
o La función leerTarjeta muestra el UID de la tarjeta detectada.
2. Escritura en la tarjeta:
o La función escribirTarjeta solicita al operador el sector y bloque donde se
escribirán los datos.
o Se verifica que no se intente escribir en el sector de identificación (sector 0).
o Se solicitan los datos a escribir en formato hexadecimal.
3. Verificación de acceso:
o La función verificarAcceso compara el UID de la tarjeta con la lista de UIDs
autorizados.
o Si la tarjeta está autorizada, se activa el pin 4 (LED verde y relé).
o Si no está autorizada, se activa el pin 8 (LED rojo).
4. Manejo de entradas del operador:
o Se validan las entradas del operador para evitar errores (por ejemplo, no permitir
escribir en el sector 0).
Pruebas y consideraciones
 Asegúrate de que las conexiones del LED verde, LED rojo y relé estén correctamente
realizadas.
 Verifica que las tarjetas NFC sean compatibles con el módulo PN532.
 Si encuentras algún problema, utiliza mensajes de depuración ([Link]) para
identificar el origen del error.

Sistema Seguro de Tarjetas NFC para Datos Médicos en Venezuela (Resistente a Sanciones
y Ataques)

Objetivo
Crear un sistema seguro y descentralizado que permita:
1. Identificar pacientes en cualquier centro de salud.
2. Almacenar datos médicos críticos en la tarjeta NFC (funcionalidad offline).
3. Actualizar diagnósticos de forma segura (solo por personal autorizado).
4. Resistir ciberataques, sanciones externas y fallas de infraestructura.

Recomendaciones de Seguridad y Funcionalidad

1. Autenticación y Control de Acceso Estricto
a) Doble factor de autenticación (2FA) para personal médico: credenciales + huella dactilar
o token físico.
b) Jerarquía de permisos:
-Solo lectura: Paramédicos (ver alergias, enfermedades crónicas).
-Lectura/escritura: Médicos (agregar nuevos diagnósticos).
2. Cifrado de Datos y Protección contra Clonación
a) Cifrado AES-256 en la tarjeta.
b) Certificado digital único por tarjeta, emitido por el Ministerio del Poder Popular de Salud.
c) Modo seguro EV2 (ISO/IEC 14443) para evitar skimming o falsificación.
3. Datos Almacenados en la Tarjeta (Funcionalidad Offline)
La tarjeta contendrá información crítica para emergencias, incluso si los servidores están caídos:
a) Identificación básica: nombre, cédula, fecha de nacimiento, tipo sanguíneo.
b) Enfermedades crónicas: diabetes, hipertensión, VIH (con consentimiento), cáncer, asma
grave.
c) Alertas médicas:
-Alergias (ej. penicilina, alimentos).
-Medicamentos actuales (ej. insulina, anticoagulantes).
-Implantes (marcapasos, prótesis).
d) Contacto de emergencia: teléfono de familiar o médico tratante.
Nota: Datos sensibles como VIH requieren consentimiento explícito y cifrado adicional.
4. Sistema Híbrido (Tarjeta + Base de Datos Nacional)
a) La tarjeta actúa como "llave maestra" para acceder al historial completo en servidores
(cuando hay conexión).
b) Sincronización segura: al conectarse, los centros de salud actualizan la BD nacional
mediante TLS 1.3.
c) Respaldo distribuido: réplicas de la BD en hospitales regionales para evitar pérdida de
datos.
5. Resistencia a Ataques y Sanciones
a) Operación offline priorizada: la tarjeta funciona sin servidores.
b) Infraestructura nacional: evitar dependencia de cloud extranjero (ej. AWS, Google
Cloud).
c) Código abierto auditado: para garantizar transparencia y detectar backdoors.
6. Auditoría y Respuesta a Incidentes
a) Registro inmutable de accesos (ej. blockchain privado).
b) Alertas en tiempo real por intentos de acceso masivo o no autorizado.
c) Borrado remoto: en caso de robo, invalidar la tarjeta vía SMS o app vinculada.
7. Protección Física
a) Material resistente a daños y agua.
b) RFID shielding para evitar lecturas no autorizadas.

Escenarios de Uso
1. Sin conexión a internet:
a) Ejemplo: Paciente con diabetes llega inconsciente a un rural. El médico lee su
NFC y ve: "Diabetes tipo 2, alergia a metformina, último tratamiento: insulina
NPH".
b) Acción: Evitar metformina y ajustar dosis de insulina.
2. Ataque a servidores (ej. julio/2024):
a) La tarjeta sigue proporcionando datos vitales.
b) Nuevos diagnósticos se registran localmente y se sincronizan luego.

Implementación por Fases

1. Piloto en Caracas/Maracaibo: Pruebas en hospitales con alta demanda.
2. Capacitación: Personal médico en seguridad y uso de lectores NFC.
3. Expansión nacional: Priorizando zonas rurales con mala conectividad.

Conclusión
Este sistema garantiza:
1. Acceso rápido a datos críticos (aún sin internet).
2. Protección contra ciberataques y sanciones.
3. Privacidad del paciente (cifrado + consentimiento).
4. Resistencia geopolítica (infraestructura 100% soberana).

Nota final: Incluir un mecanismo de consentimiento dinámico (ej. el paciente puede ocultar
ciertos datos en la NFC si lo desea).