Lecteur RFID RC522

/*
 * Premier badge — Kaihatsu Lab
 * Lecteur RC522 (SPI) sur ESP32 : affiche l'UID et le type de chaque carte présentée.
 * Bibliothèque : MFRC522 (gestionnaire de bibliothèques de l'IDE Arduino).
 */
#include <SPI.h>
#include <MFRC522.h>

// Broches ESP32 (VSPI). Adaptez-les à votre câblage.
const uint8_t PIN_SCK  = 18;
const uint8_t PIN_MISO = 19;
const uint8_t PIN_MOSI = 23;
const uint8_t PIN_SS   = 5;
const uint8_t PIN_RST  = 22;

MFRC522 rfid(PIN_SS, PIN_RST);

void setup() {
  Serial.begin(115200);
  SPI.begin(PIN_SCK, PIN_MISO, PIN_MOSI, PIN_SS);
  rfid.PCD_Init();
  delay(50);
  rfid.PCD_DumpVersionToSerial();       // 0x91 ou 0x92 : puce reconnue. 0x00 ou 0xFF : problème de câblage.
  Serial.println(F("Approche une carte du lecteur..."));
}

void loop() {
  if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) return;

  Serial.print(F("UID :"));
  for (byte i = 0; i < rfid.uid.size; i++) {
    Serial.print(rfid.uid.uidByte[i] < 0x10 ? " 0" : " ");
    Serial.print(rfid.uid.uidByte[i], HEX);
  }
  Serial.println();

  MFRC522::PICC_Type type = rfid.PICC_GetType(rfid.uid.sak);
  Serial.print(F("Type : "));
  Serial.println(rfid.PICC_GetTypeName(type));

  rfid.PICC_HaltA();                    // carte en veille : elle ne sera relue qu'après avoir été retirée puis représentée
  rfid.PCD_StopCrypto1();
}

/*
 * Lecture d'un bloc MIFARE Classic — Kaihatsu Lab
 * Authentification avec la clé A d'usine (FF FF FF FF FF FF), puis lecture du bloc 4
 * affiché en hexadécimal et en texte.
 */
#include <SPI.h>
#include <MFRC522.h>

const uint8_t PIN_SS  = 5;
const uint8_t PIN_RST = 22;
const byte    BLOCK   = 4;              // secteur 1 : blocs 4, 5 et 6 pour les données, le 7 est la « trailer »

MFRC522 rfid(PIN_SS, PIN_RST);
MFRC522::MIFARE_Key key;

void setup() {
  Serial.begin(115200);
  SPI.begin(18, 19, 23, PIN_SS);        // SCK, MISO, MOSI, SS
  rfid.PCD_Init();
  for (byte i = 0; i < 6; i++) key.keyByte[i] = 0xFF;   // clé d'usine
  Serial.println(F("Approche une carte MIFARE Classic..."));
}

void loop() {
  if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) return;

  MFRC522::StatusCode status = rfid.PCD_Authenticate(
      MFRC522::PICC_CMD_MF_AUTH_KEY_A, BLOCK, &key, &(rfid.uid));

  if (status != MFRC522::STATUS_OK) {
    Serial.print(F("Authentification refusee : "));
    Serial.println(rfid.GetStatusCodeName(status));
  } else {
    byte buffer[18];                    // 16 octets de données + 2 octets de CRC
    byte size = sizeof(buffer);
    status = rfid.MIFARE_Read(BLOCK, buffer, &size);

    if (status == MFRC522::STATUS_OK) {
      Serial.print(F("Bloc "));
      Serial.print(BLOCK);
      Serial.print(F(" :"));
      for (byte i = 0; i < 16; i++) {
        Serial.print(buffer[i] < 0x10 ? " 0" : " ");
        Serial.print(buffer[i], HEX);
      }
      Serial.print(F("  | "));
      for (byte i = 0; i < 16; i++) {
        Serial.print(buffer[i] >= 32 && buffer[i] < 127 ? (char)buffer[i] : '.');
      }
      Serial.println();
    } else {
      Serial.print(F("Lecture impossible : "));
      Serial.println(rfid.GetStatusCodeName(status));
    }
  }

  rfid.PICC_HaltA();
  rfid.PCD_StopCrypto1();               // à appeler après toute authentification
}

/*
 * Écriture d'un bloc MIFARE Classic — Kaihatsu Lab
 * Écrit un texte de 16 caractères maximum dans le bloc 4, puis relit le bloc pour vérifier.
 *
 * ATTENTION : n'écris jamais dans le bloc 0 ni dans un « sector trailer » (blocs 3, 7, 11, 15...).
 * Le trailer contient les clés et les droits d'accès : une erreur peut rendre le secteur définitivement illisible.
 */
#include <SPI.h>
#include <MFRC522.h>

const uint8_t PIN_SS  = 5;
const uint8_t PIN_RST = 22;
const byte    BLOCK   = 4;
const char    TEXT[]  = "KAIHATSU LAB";  // 16 caractères maximum

MFRC522 rfid(PIN_SS, PIN_RST);
MFRC522::MIFARE_Key key;

void setup() {
  Serial.begin(115200);
  SPI.begin(18, 19, 23, PIN_SS);
  rfid.PCD_Init();
  for (byte i = 0; i < 6; i++) key.keyByte[i] = 0xFF;

  if (BLOCK == 0 || (BLOCK % 4) == 3) {
    Serial.println(F("Bloc interdit : choisis un bloc de donnees (4, 5, 6, 8, 9, 10...)."));
    while (true) delay(1000);
  }
  Serial.println(F("Approche une carte MIFARE Classic pour ecrire..."));
}

void loop() {
  if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) return;

  MFRC522::StatusCode status = rfid.PCD_Authenticate(
      MFRC522::PICC_CMD_MF_AUTH_KEY_A, BLOCK, &key, &(rfid.uid));

  if (status == MFRC522::STATUS_OK) {
    byte data[16] = {0};
    size_t n = strlen(TEXT);
    if (n > 16) n = 16;
    memcpy(data, TEXT, n);

    status = rfid.MIFARE_Write(BLOCK, data, 16);
    if (status == MFRC522::STATUS_OK) {
      byte check[18];
      byte size = sizeof(check);
      if (rfid.MIFARE_Read(BLOCK, check, &size) == MFRC522::STATUS_OK && memcmp(check, data, 16) == 0) {
        Serial.println(F("Ecriture verifiee."));
      } else {
        Serial.println(F("Ecriture faite, mais la relecture ne correspond pas."));
      }
    } else {
      Serial.print(F("Ecriture impossible : "));
      Serial.println(rfid.GetStatusCodeName(status));
    }
  } else {
    Serial.print(F("Authentification refusee : "));
    Serial.println(rfid.GetStatusCodeName(status));
  }

  rfid.PICC_HaltA();
  rfid.PCD_StopCrypto1();
}

/*
 * Serrure à badge — Kaihatsu Lab
 * RC522 (SPI) + écran OLED SSD1306 (I2C) + servomoteur sur ESP32.
 * Un badge autorisé affiche « ACCES OK » et ouvre le servo trois secondes.
 *
 * Bibliothèques : MFRC522, Adafruit GFX, Adafruit SSD1306, ESP32Servo.
 */
#include <SPI.h>
#include <MFRC522.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <ESP32Servo.h>

// RC522 (SPI) : SCK 18, MISO 19, MOSI 23
const uint8_t PIN_SS  = 5;
const uint8_t PIN_RST = 27;             // pas 22 : le GPIO 22 est déjà le SCL de l'écran

// OLED (I2C) : SDA 21, SCL 22
#define SCREEN_W  128
#define SCREEN_H  64
#define OLED_ADDR 0x3C

// Servo
const uint8_t  PIN_SERVO    = 13;
const int      ANGLE_CLOSED = 0;
const int      ANGLE_OPEN   = 90;
const uint32_t OPEN_MS      = 3000;

// Badges autorisés (UID de 4 octets) : ajoute une ligne par badge
const byte AUTHORIZED[][4] = {
  {0x04, 0xA3, 0x7B, 0x2C},
};
const uint8_t AUTHORIZED_COUNT = sizeof(AUTHORIZED) / sizeof(AUTHORIZED[0]);

MFRC522 rfid(PIN_SS, PIN_RST);
Adafruit_SSD1306 display(SCREEN_W, SCREEN_H, &Wire, -1);
Servo door;

bool isAuthorized() {
  if (rfid.uid.size != 4) return false;
  for (uint8_t i = 0; i < AUTHORIZED_COUNT; i++) {
    if (memcmp(rfid.uid.uidByte, AUTHORIZED[i], 4) == 0) return true;
  }
  return false;
}

String uidToString() {
  String s;
  for (byte i = 0; i < rfid.uid.size; i++) {
    if (rfid.uid.uidByte[i] < 0x10) s += '0';
    s += String(rfid.uid.uidByte[i], HEX);
    if (i < rfid.uid.size - 1) s += ' ';
  }
  s.toUpperCase();
  return s;
}

void screen(const char* title, const String& uid, const char* result) {
  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);
  display.setTextSize(1);
  display.setCursor(0, 0);
  display.print(title);
  display.setCursor(0, 14);
  display.print(uid);
  display.setTextSize(2);
  display.setCursor(0, 40);
  display.print(result);
  display.display();
}

void setup() {
  Serial.begin(115200);
  SPI.begin(18, 19, 23, PIN_SS);
  rfid.PCD_Init();

  Wire.begin(21, 22);
  display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR);

  door.setPeriodHertz(50);
  door.attach(PIN_SERVO, 500, 2400);    // impulsions min et max en microsecondes
  door.write(ANGLE_CLOSED);

  screen("BADGE", "", "");
}

void loop() {
  if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) return;

  String uid = uidToString();
  bool ok = isAuthorized();
  screen("BADGE", uid, ok ? "ACCES OK" : "REFUSE");

  if (ok) {
    door.write(ANGLE_OPEN);
    delay(OPEN_MS);
    door.write(ANGLE_CLOSED);
  } else {
    delay(1500);
  }

  screen("BADGE", "", "");
  rfid.PICC_HaltA();
  rfid.PCD_StopCrypto1();
}