RFID RC522 con Arduino: accendere un LED e memorizzare fino a 3 TAG

/*
  LETTURA UID RFID RC522

  Collegamenti RC522 con Arduino Uno:
  SDA / SS -> D10
  SCK      -> D13
  MOSI     -> D11
  MISO     -> D12
  RST      -> D9
  3.3V     -> 3.3V
  GND      -> GND

  Lo sketch stampa sul Monitor Seriale il codice
  della tessera/tag in formato decimale ed esadecimale.
*/

#include <SPI.h>
#include <RFID.h>

#define SS_PIN 10
#define RST_PIN 9

RFID rfid(SS_PIN, RST_PIN);

// Memorizza l'ultimo UID letto
int ultimoUid[5] = {-1, -1, -1, -1, -1};

void setup() {

  Serial.begin(9600);

  SPI.begin();
  rfid.init();

  Serial.println("Avvicina una tessera o un tag RFID...");
}

void loop() {

  // Controlla se è presente una tessera
  if (!rfid.isCard()) {
    return;
  }

  // Legge il seriale della tessera
  if (!rfid.readCardSerial()) {
    return;
  }

  bool nuovoTag = false;

  for (byte i = 0; i < 5; i++) {
    if (rfid.serNum[i] != ultimoUid[i]) {
      nuovoTag = true;
      break;
    }
  }

  if (nuovoTag) {

    Serial.println();
    Serial.println("Tessera rilevata");

    Serial.print("Dec: ");

    for (byte i = 0; i < 5; i++) {
      ultimoUid[i] = rfid.serNum[i];
      Serial.print(rfid.serNum[i], DEC);

      if (i < 4) {
        Serial.print(", ");
      }
    }

    Serial.println();

    Serial.print("Hex: ");

    for (byte i = 0; i < 5; i++) {
      Serial.print(rfid.serNum[i], HEX);

      if (i < 4) {
        Serial.print(", ");
      }
    }

    Serial.println();
  }

  rfid.halt();
}

const byte MASTER_UID[5] = {
  252, 162, 51, 59, 86
};

/*
  RFID RC522: ACCENSIONE / SPEGNIMENTO LED CON TAG MEMORIZZATI

  Funzioni:
  - una tessera MASTER abilita la modalità registrazione
  - si possono memorizzare fino a 3 TAG nella EEPROM
  - un TAG autorizzato alterna LED verde ON/OFF
  - un TAG non autorizzato accende temporaneamente il LED rosso
  - il pulsante reset cancella i TAG solo quando è attiva
    la modalità MASTER

  Collegamenti RC522:
  SDA / SS -> D10
  RST      -> D9
  MOSI     -> D11
  MISO     -> D12
  SCK      -> D13
  Alimentazione RC522 -> 3.3 V

  LED verde -> D7
  LED rosso -> D2
  Pulsante reset -> D6
*/

#include <SPI.h>
#include <RFID.h>
#include <EEPROM.h>

#define SS_PIN 10
#define RST_PIN 9

const byte LED_VERDE = 7;
const byte LED_ROSSO = 2;
const byte RESET_KEY = 6;

// UID della tessera MASTER.
// Sostituisci questi 5 valori con quelli letti
// tramite lo sketch di lettura.
const byte MASTER_UID[5] = {
  252, 162, 51, 59, 86
};

RFID rfid(SS_PIN, RST_PIN);

bool ledAcceso = false;
bool modalitaMaster = false;

// Numero di TAG slave salvati.
// EEPROM[0] contiene 0, 1, 2 oppure 3.
byte numeroTag = 0;

// UID appena letto
byte uid[5];

// Indirizzi iniziali dei tre TAG nella EEPROM
const byte TAG_ADDRESS[3] = {1, 6, 11};

void setup() {

  Serial.begin(9600);

  SPI.begin();
  rfid.init();

  pinMode(LED_VERDE, OUTPUT);
  pinMode(LED_ROSSO, OUTPUT);

  // Il pulsante usa la resistenza interna:
  // premuto = LOW.
  pinMode(RESET_KEY, INPUT_PULLUP);

  digitalWrite(LED_VERDE, LOW);
  digitalWrite(LED_ROSSO, LOW);

  numeroTag = EEPROM.read(0);

  // Protezione nel caso la EEPROM contenga un valore non valido
  if (numeroTag > 3) {
    numeroTag = 0;
    EEPROM.update(0, 0);
  }

  stampaPronto();
}

void loop() {

  // ----------------------------------------------------
  // RESET TAG:
  // consentito soltanto quando la modalità MASTER è attiva
  // ----------------------------------------------------
  if (modalitaMaster && digitalRead(RESET_KEY) == LOW) {

    cancellaTag();

    modalitaMaster = false;

    Serial.println("TAG memorizzati cancellati.");
    delay(500);

    stampaPronto();
  }

  // Nessuna tessera presente
  if (!rfid.isCard()) {
    return;
  }

  // Impossibile leggere l'UID
  if (!rfid.readCardSerial()) {
    return;
  }

  // Copia l'UID appena letto
  for (byte i = 0; i < 5; i++) {
    uid[i] = rfid.serNum[i];
  }

  // ----------------------------------------------------
  // 1. TESSERA MASTER
  // ----------------------------------------------------
  if (uidUguale(uid, MASTER_UID)) {

    modalitaMaster = !modalitaMaster;

    if (modalitaMaster) {
      numeroTag = EEPROM.read(0);

      Serial.println("CARD MASTER");
      Serial.println("Modalita registrazione TAG ATTIVA");
      Serial.print("TAG memorizzati: ");
      Serial.println(numeroTag);
    }
    else {
      Serial.println("Modalita registrazione TAG DISATTIVATA");
    }

    delay(1000);
    rfid.halt();
    return;
  }

  // ----------------------------------------------------
  // 2. TAG GIA' AUTORIZZATO
  // ----------------------------------------------------
  if (tagAutorizzato(uid)) {

    ledAcceso = !ledAcceso;

    digitalWrite(
      LED_VERDE,
      ledAcceso ? HIGH : LOW
    );

    if (ledAcceso) {
      Serial.println("TAG valido: LED VERDE ACCESO");
    }
    else {
      Serial.println("TAG valido: LED VERDE SPENTO");
    }

    delay(800);
    rfid.halt();
    return;
  }

  // ----------------------------------------------------
  // 3. MODALITA MASTER: MEMORIZZA UN NUOVO TAG
  // ----------------------------------------------------
  if (modalitaMaster) {

    if (numeroTag < 3) {

      salvaTag(numeroTag, uid);

      numeroTag++;

      EEPROM.update(0, numeroTag);

      Serial.print("Nuovo TAG memorizzato. Totale: ");
      Serial.println(numeroTag);

      // Dopo una registrazione usciamo dalla modalità MASTER
      modalitaMaster = false;
    }
    else {
      Serial.println("Memoria piena: massimo 3 TAG.");
    }

    delay(1000);
    rfid.halt();
    return;
  }

  // ----------------------------------------------------
  // 4. TAG NON AUTORIZZATO
  // ----------------------------------------------------
  Serial.println("TAG non autorizzato");

  digitalWrite(LED_ROSSO, HIGH);
  delay(1500);
  digitalWrite(LED_ROSSO, LOW);

  rfid.halt();
}

// ------------------------------------------------------
// Confronta due UID da 5 byte
// ------------------------------------------------------
bool uidUguale(const byte a[5], const byte b[5]) {

  for (byte i = 0; i < 5; i++) {
    if (a[i] != b[i]) {
      return false;
    }
  }

  return true;
}

// ------------------------------------------------------
// Controlla se il TAG è presente nei tre slot EEPROM
// ------------------------------------------------------
bool tagAutorizzato(const byte tag[5]) {

  for (byte slot = 0; slot < numeroTag && slot < 3; slot++) {

    byte salvato[5];

    leggiTag(slot, salvato);

    if (uidUguale(tag, salvato)) {
      return true;
    }
  }

  return false;
}

// ------------------------------------------------------
// Salva un UID in uno dei tre slot EEPROM
// ------------------------------------------------------
void salvaTag(byte slot, const byte tag[5]) {

  if (slot >= 3) {
    return;
  }

  byte indirizzo = TAG_ADDRESS[slot];

  for (byte i = 0; i < 5; i++) {
    EEPROM.update(indirizzo + i, tag[i]);
  }
}

// ------------------------------------------------------
// Legge un UID salvato
// ------------------------------------------------------
void leggiTag(byte slot, byte tag[5]) {

  byte indirizzo = TAG_ADDRESS[slot];

  for (byte i = 0; i < 5; i++) {
    tag[i] = EEPROM.read(indirizzo + i);
  }
}

// ------------------------------------------------------
// Cancella contatore e tre slot TAG
// ------------------------------------------------------
void cancellaTag() {

  for (byte i = 0; i < 16; i++) {
    EEPROM.update(i, 0);
  }

  numeroTag = 0;
}

void stampaPronto() {
  Serial.println("RFID RC522 pronto.");
}