Construye un Lector RFID Habilitado para Red con Arduino, Ethernet ENC28J60 y MFRC522

Componentes y suministros

Mifare MFRC522	×1	Cualquier tipo de lector RFID SPI sirve
Arduino UNO	×1	Cualquier Arduino sirve
enc28j60	×1	Deberás modificar el código para cualquier cosa que no use ENC28J60
Cables jumper (genéricos)	×1
Protoboard (genérica)	×1
Computadora	×1	Cualquier computadora que se conecte a internet

Herramientas y máquinas necesarias

• Tijeras (o pelacables)

Aplicaciones y servicios en línea

• PyCharm
• Arduino IDE

Sobre este proyecto

¿Alguna vez pensaste en añadir un sistema de seguridad o monitoreo con etiquetas/tarjetas RFID en tu casa y/u oficina? Bueno, si llegaste aquí, apuesto a que ya buscaste lo caros que son, oscilando entre $200 y $2000, ¡DEMASIADO CARO! Un amigo y yo decidimos hacer un sistema que costara menos de $100 y pudiera hacer incluso más que solo abrir una puerta. Así surgió este lector RFID habilitado para internet. Por $20 más puede abrir puertas. Este sistema fue diseñado para rastrear estudiantes en nuestra escuela secundaria y esperamos que la escuela lo apruebe.

Podrías pensar que llevaría mucho tiempo, pero esto solo me tomó unas 6 horas (porque tuve problemas de alimentación), pero te podría tomar unos 30 minutos configurarlo como el ejemplo de arriba. Todo el código e imágenes están abajo, así que si te confundes en los siguientes pasos, adelante y mira las imágenes/código de abajo.

Antes de empezar (Necesario)

Antes de poder empezar a escanear tarjetas y enviarlas a nuestro servidor Telnet/TCP necesitamos algunas librerías:

• Obtén UIPEthernet aquí: https://github.com/ntruchsess/arduino_uip
• Obtén MFRC522 aquí: https://github.com/miguelbalboa/rfid

Pon ambas librerías en Archivos de programa(x86)/Arduino/Libraries/ y reinicia Arduino.

Hardware

1. Arduino Nano (puedes modificar tu código para adaptarlo a tu dispositivo)
2. MFRC522 con tarjetas MIFARE
3. Cables jumper (Macho-Macho, Macho-Hembra)
4. Módulo/shield Ethernet enc28j60
5. LED RGB
6. Convertidor AC-DC de 3V O 5V mayor a 700 mA

Configuración

1. Conecta Arduino a la protoboard (si es Nano o Micro)
2. Busca online el pinout de tu placa para encontrar la configuración SPI (cambia los valores de abajo)
3. Conecta pin 10 de Arduino (SS) al SS o CS del módulo Ethernet
4. Conecta pin 12 de Arduino (MISO) a MISO del RFID y SO del Ethernet
5. Conecta pin 11 de Arduino (MOSI) a MOSI del RFID y SI del Ethernet
6. Conecta pin 13 de Arduino (SCK) a SCK del RFID y SCK del Ethernet
7. Conecta pin 9 de Arduino a pin RST del RFID
8. Conecta pin 8 de Arduino a pin SSN del RFID
9. Conecta pin 5 a LED verde, 4 a azul y 3 a rojo
10. Conecta tu AC-DC a + y - en tu protoboard
11. Conecta a tierra tu Arduino al AC-DC
12. Conecta VCC y GND en tanto el RFID como el Ethernet al AC-DC (¡RECUERDA QUE ESTOS DISPOSITIVOS SON SOLO 3V!!!!! no suministres 5V) Si hay problema, usa resistencias para bajar el voltaje a 3V
13. Conecta pin VCC del LED al Arduino 3V o AC-DC 3V
14. Conecta cable Ethernet al módulo y asegúrate de que esté en la misma red que tu computadora
15. Conecta cable USB de computadora a Arduino
16. Conecta computadora a la misma red

Modifica el código para adaptarlo a tus necesidades

1. El código está bastante bien comentado así que puedes entrar y modificar ciertas partes, pero una cosa segura es el módulo Ethernet
2. La dirección MAC puede quedarse igual (a menos que planees construir varios de estos)
3. Si usas una red base 192.168. puedes mantener la IP
4. De nuevo puedes mantener el DNS, solo hay que cambiarlo a 8.8.4.4 si es necesario

5. Ejecuta ipconfig para encontrar tu gateway, el default es 192.168.1.1 (si no lo sabes) (El código actual es 192.168.1.5)
6. Ejecuta símbolo del sistema y escribe ipconfig para averiguar la IP de tu computadora

7. Desplázate hacia abajo para encontrar SEND TO SERVER, e ingresa la IP de tu computadora o si hiciste port forwarding en tu router a tu IP pública
8. ASEGÚRATE DE TENER PYTHON Y EJECUTAR EL SERVIDOR (Recuerda que es solo un código de ejemplo que usamos para nuestra presentación a la escuela, así que el servidor Python ya estaba prehecho y casi no modificado; puedes usar cualquier servidor Telnet/TCP)

Y el otro código que probablemente necesitarás modificar:

Ejecutando el código

1. Conecta alimentación AC-DC a la pared
2. Asegúrate de que tu Arduino esté conectado a la computadora
3. Asegúrate de que ambos dispositivos estén en la misma red
4. Flashea tu código Arduino modificado o si el que tengo funciona para ti, genial (casi ninguna posibilidad de que tengas que modificarlo)
5. Inicia tu script Python, C++ o cualquier servidor Telnet/TCP en tu red
6. Reinicia tu Arduino por seguridad
7. Espera hasta que la luz se ponga azul y prueba escaneando una tarjeta; si tu servidor recibió el ID de la tarjeta, ¡estás listo!
8. Recuerda qué significan las luces: Púrpura/rojo desvanecido = arrancando
9. Rojo = cualquier error, como tarjeta en ángulo raro y/o el servidor no respondió a tiempo
10. Verde = éxito, el servidor respondió con OK y puedes leer la siguiente tarjeta
11. Azul = esperando/cargando, esperando tarjeta o respuesta
12. Si tu Arduino empieza a ir lento y tarda más de 30 segundos en mostrar luz roja, significa que el módulo Ethernet no pudo conectar al servidor. Esto puede ser por múltiples cosas: primero, tu Arduino no tiene suficiente energía y el módulo Ethernet lucha por enviar un paquete; o que tu servidor en la computadora no está corriendo; o que tu Arduino y computadora no están en la misma red.
13. Si tu Arduino sigue fallando, prueba estos trucos para arreglarlos:
    • Apaga el firewall de Windows
    • Ve a configuración avanzada de firewall y permite puerto 23 entrante/saliente
    • Haz port forwarding en tu router a tu computadora con puerto 23
    • Si eres inalámbrico, conecta el Arduino directo al router y tu computadora al mismo
    • Compra un adaptador AC-DC más robusto
    • Sino, tal vez ingresaste mal la IP o dirección de conexión
    • Si nada funciona, contáctame en smerkousdavid@gmail.com
14. ¡LISTO PARA USAR!

Recuerda que no hay código para el sistema de cerradura de puerta, porque no tengo uno, esto significa que tendrás que añadir algo de código si quieres usar esto no solo como sistema de rastreo sino como sistema de rastreo y cerradura de puerta.

Código

Código Arduino

/* * ---------------------------------- * MFRC522 Arduino * Reader/PCD Nano v3 * Signal Pin Pin * ---------------------------------- * RST/Reset RST D9 * SPI SS NSS D10 * SPI MOSI MOSI D11 * SPI MISO MISO D12 * SPI SCK SCK D13 */ 
// LA PRIMERA LIBRERÍA QUE NECESITA INSTALARSE ES UIP ETHERNET, LA SEGUNDA ES MFRC522, AMBAS EN GITHUB
#include <UIPEthernet.h>
#include <SPI.h> // Para la selección de la clave
#include <MFRC522.h> // La librería RFID

#define RST_PIN 9 // Configurable, ver pinout típico arriba - Esto es para Arduino Nano - Para RFID
#define SS_PIN 8 // USAMOS 8 PARA RFID PORQUE EL MÓDULO ETHERNET USA 10

byte sector = 0;
byte blockAddr = 0;
//////// Acceder a ciertos sectores/bloques en la tarjeta, el bloque trailer es el último bloque
byte trailerBlock = 1;

int red = 3;
int blue = 4; // Pines para LED RGB
int green = 5;

EthernetClient client; // INSTANCIA ETHERNET
MFRC522 mfrc522(SS_PIN, RST_PIN); // Crear instancia MFRC522.
MFRC522::MIFARE_Key key; // Establecer instancia de clave
signed long timeout; // TIMEOUT PARA QUE NO SE QUEDE AHÍ PARA SIEMPRE

void setup() {
  // UI BEGIN
  pinMode(red, OUTPUT);
  pinMode(blue, OUTPUT); // Iniciar LED RGB
  pinMode(green, OUTPUT);
  Reset(); // Empezar con LEDs apagados
  Serial.begin(9600); // Iniciar conexión con computadora a 9600 bps
  // UI END

  // INICIALIZACIÓN MÓDULO ETHERNET
  SPI.begin(); // Iniciar bus SPI
  uint8_t mac[6] = {0x00,0x01,0x02,0x03,0x04,0x05}; // MAC = 000102030405
  IPAddress mip(192,168,1,160); // IP = 192.168.1.160
  IPAddress mdns(8,8,8,8); // DNS = 8.8.8.8
  IPAddress mgate(192,168,1,5); // GATEWAY = 192.168.1.5
  IPAddress msubnet(255,255,255,0); // SUBNET = 255.255.255.0
  Ethernet.begin(mac, mip, mdns, mgate , msubnet); // CONECTAR USANDO LO ANTERIOR
  Serial.println("Conexión exitosa");
  // FIN ETHERNET

  for(int t = 255; t > 0; t--) {
    analogWrite(red, t); // Más que nada show pero deja al menos un segundo entre el SPI del ethernet y RFID
    delay(10);
  }

  // INICIALIZACIÓN RFID
  mfrc522.PCD_Init(); // Iniciar tarjeta MFRC522
  for (byte i = 0; i < 6; i++) { // Preparar la clave (usada tanto como clave A como clave B)
    key.keyByte[i] = 0xFF; // usando FFFFFFFFFFFFh que es el default al salir de fábrica
  }
  Serial.println(F("Escanea una Tarjeta"));
  dump_byte_array(key.keyByte, MFRC522::MF_KEY_SIZE); // Obtener tamaño de clave
  timeout = 0;
  delay(2000);
  Reset();
} // FIN INICIALIZACIÓN RFID

void loop() { // Ejecutar para siempre
  // Buscar nuevas tarjetas
  if ( ! mfrc522.PICC_IsNewCardPresent()) {
    digitalWrite(blue, LOW);
    return;
  }
  // Seleccionar una de las tarjetas
  if ( ! mfrc522.PICC_ReadCardSerial()) return;
  digitalWrite(blue, HIGH); // Mostrar usuario que tarjeta ha sido leída
  byte piccType = mfrc522.PICC_GetType(mfrc522.uid.sak); // Verificar compatibilidad con tarjeta Mifare
  if ( piccType != MFRC522::PICC_TYPE_MIFARE_MINI && piccType != MFRC522::PICC_TYPE_MIFARE_1K && piccType != MFRC522::PICC_TYPE_MIFARE_4K) {
    Error();
    return;
  }
  byte status;
  byte buffer[18];
  byte size = sizeof(buffer);
  status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid));
  if (status != MFRC522::STATUS_OK) {
    Serial.print(F("PCD_Authenticate() failed: "));
    Serial.println(mfrc522.GetStatusCodeName(status));
    Error();
    return;
  }
  // Leer datos del bloque
  status = mfrc522.MIFARE_Read(blockAddr, buffer, &size);
  if (status != MFRC522::STATUS_OK) {
    Serial.print(F("MIFARE_Read() failed: "));
    Serial.println(mfrc522.GetStatusCodeName(status));
    Error();
  }
  // Detener PICC
  mfrc522.PICC_HaltA();
  // Detener encriptación en PCD
  mfrc522.PCD_StopCrypto1();

  // DESPUÉS DE LEER TARJETA ENVIAR AL SERVIDOR
  if (client.connect(IPAddress(192,168,1,100),23)) {
    timeout = millis()+1000;
    Serial.println("Cliente conectado");
    const String ID = dump_byte_array(buffer, size);
    client.println(ID);
    Serial.println("enviado :" + ID);
    delay(10);
    while(client.available()==0) {
      if (timeout - millis() < 0) goto close;
    }
    int size;
    while((size = client.available()) > 0) {
      uint8_t* msg = (uint8_t*)malloc(size);
      size = client.read(msg,size);
      Serial.write(msg,size);
      if(size == sizeof("g") - 1) {
        Pass();
      } else {
        Error();
      }
      free(msg);
    }
    close:
    client.stop();
  } else {
    Serial.println("No se pudo conectar al Servidor");
    Error();
  }
  // FIN DE ENVÍO AL SERVIDOR
  Reset(); // REINICIAR BUCLE SIN LEDs ENCENDIDOS
} 

// CONVERTIR ARRAY BUFFER EN UNA SOLA CADENA EN MAYÚSCULAS QUE ES NUESTRO ID DEL SECTOR Y BLOQUE
String dump_byte_array(byte *buffer, byte bufferSize) {
  String out = "";
  for (byte i = 0; i < bufferSize; i++) {
    out += String(buffer[i] < 0x10 ? " 0" : " ") + String(buffer[i], HEX);
  }
  out.toUpperCase();
  out.replace(" ", "");
  return out;
} // FIN DUMP_BYTE_ARRAY

// ABAJO ESTÁN LOS MÉTODOS DEL LED
void Error() {
  digitalWrite(red, LOW);
  delay(700);
  digitalWrite(red, HIGH);
}

void Pass() {
  digitalWrite(green, LOW);
  delay(700);
  digitalWrite(green, HIGH);
}

void Reset() {
  digitalWrite(red, HIGH);
  digitalWrite(blue, HIGH);
  digitalWrite(green, HIGH);
} // FIN DE ARCHIVO

Código de servidor de ejemplo (Python)

import SocketServer
class MyTCPHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        # self.request es el socket TCP conectado al cliente
        self.data = self.request.recv(1024).strip()
        print "{} wrote:".format(self.client_address[0])
        print self.data
        """
        SQL STUFF HERE
        if(self.data == SQL NAME or something) {
            self.request.sendall("g")//send good
            //INSERT TIME AND LOCATION INTO SQL HERE
        } else {
            self.request.sendall("bb")//send bad
            //DO NOTHING just send to arduino bad data
        }
        """
        self.request.sendall("g")

if __name__ == "__main__":
    HOST, PORT = "", 23
    server = SocketServer.TCPServer((HOST, PORT), MyTCPHandler)
    server.serve_forever()

Código actualizado en GitHub

Aquí puedes obtener el código más actualizado: https://github.com/smerkousdavid/InternetRFIDTags

Esquemáticos

El circuito es simple así que solo hice una foto con el cableado.