ESP8266 NodeMCU avec lecteur/graveur RFID MFRC522 (Arduino)

Découvrez comment interfacer le module lecteur RFID MFRC522 avec la carte ESP8266 NodeMCU. Vous apprendrez comment obtenir des données RFID brutes, obtenir l’UID de la carte RFID et ajouter des données personnelles aux cartes RFID. Nous utiliserons la bibliothèque Arduino_MFRC522v2 et l’ESP8266 sera programmé à l’aide de l’IDE Arduino.

Nous avons un guide similaire pour l’ESP32 avec lecteur/graveur RFID MFRC522 (Arduino IDE)

En résumé, dans ce tutoriel, nous aborderons :

Lecteur/enregistreur RFID MFRC522

Dans ce didacticiel, nous utiliserons le lecteur/enregistreur RFID MFRC522 et c’est celui que nous vous recommandons d’interfacer avec l’ESP8266.

RFID signifie identification par radiofréquence. La RFID utilise des champs électromagnétiques pour transférer des données sur de courtes distances et est utile pour identifier des personnes, effectuer des transactions, etc. Certains magasins utilisent également des étiquettes RFID sur les étiquettes de leurs produits pour les identifier.

Un système RFID nécessite des étiquettes et un lecteur :

• Des étiquettes (cartes de circuit intégré de proximité – PICC) sont attachées à l’objet à identifier, dans cet exemple, nous avons un porte-clés et une carte électromagnétique fournis avec le module lecteur/enregistreur RFID MFRC522. Chaque balise possède une identification unique (UID).

• Le lecteur/enregistreur (dispositif de couplage de proximité – PCD) est un émetteur-récepteur radio bidirectionnel qui envoie un signal à l’étiquette et lit sa réponse.

Le lecteur RFID MFRC522 fonctionne à 3,3 V et prend en charge les protocoles de communication SPI et I2C. La bibliothèque que nous allons utiliser pour contrôler le lecteur RFID prend en charge les deux protocoles, mais nous utiliserons le SPI.

Pièces requises

Voici une liste des composants requis pour ce projet :

Vous pouvez utiliser les liens précédents ou vous rendre directement sur MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

Pour en savoir plus sur le lecteur RFID avec Arduino, lisez : Accès sécurisé à l’aide du lecteur RFID MFRC522 avec Arduino

Installation de la bibliothèque Arduino_MFRC522v2

Pour ce didacticiel, nous utiliserons la bibliothèque MFRC522v2.h pour contrôler le lecteur RFID. Dans l’IDE Arduino, accédez à Sketch > Inclure la bibliothèque > Gérer les bibliothèques ou cliquez sur l’icône Libary Manager dans la barre latérale gauche.

Recherchez MFRC522v2 et installez la bibliothèque par GithubCommunity.

Brochage et câblage du lecteur/enregistreur RFID MFRC522 au NodeMCU ESP8266

Nous connecterons le lecteur RFID MFRC522 à l’aide des broches SPI par défaut de l’ESP8266 NodeMCU. Vous pouvez utiliser le tableau suivant.

Remarque : cette bibliothèque est également compatible avec les cartes ESP32, Arduino et autres. Si vous utilisez une autre carte, vous pouvez vérifier l’attribution des broches de bibliothèque recommandée.

Lire les données brutes de la carte RFID – Code

L’exemple suivant lit les données brutes de l’étiquette RFID. Avec cet exemple, vous comprendrez mieux comment les données sont stockées sur les balises MIFARE 1K.

/*
  Rui Santos & Sara Santos - Raspberryme.com
  Complete project details at https://Raspberryme.com/esp8266-nodemcu-mfrc522-rfid-reader-arduino/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.  
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/

#include 
#include 
//#include 
#include 
#include 

// Learn more about using SPI/I2C or check the pin assigment for your board: https://github.com/OSSLibraries/Arduino_MFRC522v2#pin-layout
MFRC522DriverPinSimple ss_pin(15);

MFRC522DriverSPI driver{ss_pin}; // Create SPI driver
//MFRC522DriverI2C driver{};     // Create I2C driver
MFRC522 mfrc522{driver};         // Create MFRC522 instance

void setup() {
  Serial.begin(115200);  // Initialize serial communication
  while (!Serial);       // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4).
  
  mfrc522.PCD_Init();    // Init MFRC522 board.
  MFRC522Debug::PCD_DumpVersionToSerial(mfrc522, Serial);	// Show details of PCD - MFRC522 Card Reader details.
  Serial.println(F("Scan PICC to see UID, SAK, type, and data blocks..."));
}

void loop() {
  // Reset the loop if no new card present on the sensor/reader. This saves the entire process when idle.
  if (!mfrc522.PICC_IsNewCardPresent()) {
    return;
  }

  // Select one of the cards.
  if (!mfrc522.PICC_ReadCardSerial()) {
    return;
  }

  // Dump debug info about the card; PICC_HaltA() is automatically called.
  MFRC522Debug::PICC_DumpToSerial(mfrc522, Serial, &(mfrc522.uid));

  delay(2000);
}

Afficher le code brut

Après avoir câblé le circuit, téléchargez le code précédent sur votre carte.

Après le téléchargement, ouvrez le moniteur série à un débit en bauds de 115 200. Rapprochez votre balise du lecteur et voyez les informations de la balise affichées.

Il affiche l’UID de la carte, le type de tag et les blocs mémoire. Le tag est de type MIFARE avec 1 Ko de mémoire.

Voici quelques aspects essentiels à prendre en compte concernant la manière dont les données sont stockées sur la balise MIFARE 1K.

Disposition de la mémoire

La mémoire est organisée en 16 secteurs (0 à 15), et chaque secteur est divisé en 4 blocs (0 à 3), ce qui donne un total de 64 blocs. Chaque bloc peut stocker 16 octets de données (0 à 15).

Bloc fabricant

Le secteur 0, le bloc 0 stocke l’UID (les 4 premiers octets), un octet de contrôle CRC et les données du fabricant. Ceci est en lecture seule et ne peut pas être modifié (sauf sur les cartes modifiables UID). Comme vous pouvez le voir sur les résultats du Serial Monitor, l’UUID de notre balise est 82 72 9F 0B.

Stockage mémoire et bande-annonce du secteur

Les trois premiers blocs de chaque secteur peuvent être utilisés pour stocker des données. Le dernier bloc de chaque secteur est une remorque de secteur. Cette remorque de secteur stocke les 2 clés ou mots de passe et contrôle l’accès au reste des blocs du secteur. Par exemple, le bloc numéro 7 contrôle les blocs 4, 5 et 6). Il ne faut pas écrire sur ces secteurs, sinon vous risquez de bricker votre carte et elle deviendra inutilisable.

En résumé, les cartes Mifare 1K ont une capacité nette de stockage de :

(16 sectors/card x 3 data blocks/sector X 16 bytes/block) - 16 bytes (first block) = 752 bytes/card

Il y a 16 secteurs de 4 blocs chacun (64 blocs au total). Chaque bloc fait 16 octets, soit 1 024 octets au total (1 Ko). Cependant, 16 blocs (un dans chaque secteur) sont des segments de fin de secteur qui stockent les clés d’accès et les autorisations, et non les données utilisateur. Cela laisse 48 blocs disponibles pour les données utilisateur. En soustrayant 16 octets pour le bloc fabricant en lecture seule (secteur 0, bloc 0), le stockage utilisateur effectif est de 752 octets.

Lire l’UID de la carte RFID – Code

L’exemple suivant lit uniquement l’UID de l’étiquette RFID. Cela peut être utile si vous souhaitez simplement identifier la carte sans vous soucier du reste des données stockées.

/*
  Rui Santos & Sara Santos - Raspberryme.com
  Complete project details at https://Raspberryme.com/esp8266-nodemcu-mfrc522-rfid-reader-arduino/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.  
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/

#include 
#include 
//#include 
#include 
#include 

// Learn more about using SPI/I2C or check the pin assigment for your board: https://github.com/OSSLibraries/Arduino_MFRC522v2#pin-layout
MFRC522DriverPinSimple ss_pin(15);

MFRC522DriverSPI driver{ss_pin}; // Create SPI driver
//MFRC522DriverI2C driver{};     // Create I2C driver
MFRC522 mfrc522{driver};         // Create MFRC522 instance

void setup() {
  Serial.begin(115200);  // Initialize serial communication
  while (!Serial);       // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4).
  
  mfrc522.PCD_Init();    // Init MFRC522 board.
  MFRC522Debug::PCD_DumpVersionToSerial(mfrc522, Serial);	// Show details of PCD - MFRC522 Card Reader details.
	Serial.println(F("Scan PICC to see UID"));
}

void loop() {
	// Reset the loop if no new card present on the sensor/reader. This saves the entire process when idle.
	if (!mfrc522.PICC_IsNewCardPresent()) {
		return;
	}

	// Select one of the cards.
	if (!mfrc522.PICC_ReadCardSerial()) {
		return;
	}

  Serial.print("Card UID: ");
  MFRC522Debug::PrintUID(Serial, (mfrc522.uid));
  Serial.println();

  // Save the UID on a String variable
  String uidString = "";
  for (byte i = 0; i < mfrc522.uid.size; i++) {
    if (mfrc522.uid.uidByte[i] < 0x10) {
      uidString += "0"; 
    }
    uidString += String(mfrc522.uid.uidByte[i], HEX);
  }
  Serial.println(uidString);
}

Afficher le code brut

Ce code est assez simple à comprendre. Tout d’abord, vous initialisez le lecteur sur setup().

mfrc522.PCD_Init();    // Init MFRC522 board.
MFRC522Debug::PCD_DumpVersionToSerial(mfrc522, Serial);	// Show details of PCD - MFRC522 Card Reader details.
Serial.println(F("Scan PICC to see UID"));

Ensuite, dans la boucle(), vérifiez si une carte est présente.

// Reset the loop if no new card present on the sensor/reader. This saves the entire process when idle.
if (!mfrc522.PICC_IsNewCardPresent()) {
  return;
}

Si c’est le cas, lisez la carte.

// Select one of the cards.
if (!mfrc522.PICC_ReadCardSerial()) {
  return;
}

Enfin, imprimez l’UID et enregistrez-le sur une variable.

  Serial.print("Card UID: ");
  MFRC522Debug::PrintUID(Serial, (mfrc522.uid));
  Serial.println();

  // Save the UID on a String variable
  String uidString = "";
  for (byte i = 0; i < mfrc522.uid.size; i++) {
    if (mfrc522.uid.uidByte[i] < 0x10) {
      uidString += "0"; 
    }
    uidString += String(mfrc522.uid.uidByte[i], HEX);
  }
  Serial.println(uidString);
}

Téléchargez le code sur votre tableau. Ouvrez le moniteur série à un débit en bauds de 115 200.

Faites glisser différentes balises sur le lecteur et voyez leur UID unique imprimé.

Écrire/lire des données personnelles vers et depuis la carte RFID – Code

Dans cet exemple, nous allons vous montrer comment écrire des données personnalisées sur des blocs spécifiques. Ensuite, nous vous montrerons également comment lire les données de ces mêmes blocs.

/*
  Rui Santos & Sara Santos - Raspberryme.com
  Complete project details at https://Raspberryme.com/esp8266-nodemcu-mfrc522-rfid-reader-arduino/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.  
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/

#include 
#include 
//#include 
#include 
#include 

// Learn more about using SPI/I2C or check the pin assigment for your board: https://github.com/OSSLibraries/Arduino_MFRC522v2#pin-layout
MFRC522DriverPinSimple ss_pin(15);

MFRC522DriverSPI driver{ss_pin}; // Create SPI driver
//MFRC522DriverI2C driver{};     // Create I2C driver
MFRC522 mfrc522{driver};         // Create MFRC522 instance

MFRC522::MIFARE_Key key;

byte blockAddress = 2;
byte newBlockData[17] = {"Rui Santos - RNT"};
//byte newBlockData[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};   // CLEAR DATA
byte bufferblocksize = 18;
byte blockDataRead[18];

void setup() {
  Serial.begin(115200);  // Initialize serial communication
  while (!Serial);       // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4).
  
  mfrc522.PCD_Init();    // Init MFRC522 board.
  Serial.println(F("Warning: this example overwrites a block in your card, use with care!"));
 
  // Prepare key - all keys are set to FFFFFFFFFFFF at chip delivery from the factory.
  for (byte i = 0; i < 6; i++) {
    key.keyByte[i] = 0xFF;
  }
}

void loop() {
  // Check if a new card is present
  if (!mfrc522.PICC_IsNewCardPresent() || !mfrc522.PICC_ReadCardSerial()) {
    delay(500);
    return;
  }

  // Display card UID
  Serial.print("----------------\nCard UID: ");
  MFRC522Debug::PrintUID(Serial, (mfrc522.uid));
  Serial.println();

  // Authenticate the specified block using KEY_A = 0x60
  if (mfrc522.PCD_Authenticate(0x60, blockAddress, &key, &(mfrc522.uid)) != 0) {
    Serial.println("Authentication failed.");
    return;
  }
  
  // Write data to the specified block
  if (mfrc522.MIFARE_Write(blockAddress, newBlockData, 16) != 0) {
    Serial.println("Write failed.");
  } else {
    Serial.print("Data written successfully in block: ");
    Serial.println(blockAddress);
  }

  // Authenticate the specified block using KEY_A = 0x60
  if (mfrc522.PCD_Authenticate(0x60, blockAddress, &key, &(mfrc522.uid)) != 0) {
    Serial.println("Authentication failed.");
    return;
  }

  // Read data from the specified block
  if (mfrc522.MIFARE_Read(blockAddress, blockDataRead, &bufferblocksize) != 0) {
    Serial.println("Read failed.");
  } else {
    Serial.println("Read successfully!");
    Serial.print("Data in block ");
    Serial.print(blockAddress);
    Serial.print(": ");
    for (byte i = 0; i < 16; i++) {
      Serial.print((char)blockDataRead[i]);  // Print as character
    }
    Serial.println();
  }
  
  // Halt communication with the card
  mfrc522.PICC_HaltA();
  mfrc522.PCD_StopCrypto1();

  delay(2000);  // Delay for readability
}

Afficher le code brut

Comment fonctionne le code ?

Nous commençons par inclure les bibliothèques nécessaires à la configuration du lecteur RFID.

#include 
#include 
//#include 
#include 
#include 

Il définit la broche CS (Chip Select) comme broche 15, qui sera utilisée pour la communication SPI avec le lecteur.

// Learn more about using SPI/I2C or check the pin assigment for your board: https://github.com/OSSLibraries/Arduino_MFRC522v2#pin-layout
MFRC522DriverPinSimple ss_pin(15);

MFRC522DriverSPI driver{ss_pin}; // Create SPI driver
//MFRC522DriverI2C driver{};     // Create I2C driver
MFRC522 mfrc522{driver};         // Create MFRC522 instance

MFRC522::MIFARE_Key key;

Ensuite, nous définissons une variable appelée blockAddress. Ceci spécifie le bloc de l’étiquette RFID où les données seront écrites ou lues. Dans cet exemple, blockAddress est défini sur 2, ce qui signifie que le code interagira avec le bloc 2 de la mémoire de la carte. Vous pouvez modifier cette valeur si vous souhaitez écrire dans un autre bloc.

byte blockAddress = 2;

Important : le dernier bloc de chaque secteur est une remorque de secteur. Vous ne devriez pas écrire sur ce secteur, sinon vous risquez de casser votre carte.

Ensuite, newBlockData[17] contient les données que vous souhaitez écrire sur la carte. À l’heure actuelle, il est défini sur Rui Santos – RNT, mais vous pouvez le modifier. Assurez-vous qu’il ne dépasse pas 16 octets.

byte newBlockData[17] = {"Rui Santos - RNT"};

Si vous souhaitez effacer les données du bloc, vous pouvez transmettre le tableau d’octets suivant :

byte newBlockData[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

Dans setup(), initialisez le module MFRC522.

mfrc522.PCD_Init();    // Init MFRC522 board.

La clé par défaut de la carte RFID est également définie sur les lignes suivantes. Par défaut, tous les octets sont 0xFF pour la clé d’usine. Cette clé permet d’accéder aux blocs de données de la carte.

// Prepare key - all keys are set to FFFFFFFFFFFF at chip delivery from the factory.
for (byte i = 0; i < 6; i++) {
  key.keyByte[i] = 0xFF;
}

La boucle() vérifie si une nouvelle carte RFID est détectée. Si une carte est présente, il lit et affiche l’UID de la carte.

if (!mfrc522.PICC_IsNewCardPresent() || !mfrc522.PICC_ReadCardSerial()) {
  delay(500);
  return;
}

// Display card UID
Serial.print("----------------\nCard UID: ");
MFRC522Debug::PrintUID(Serial, (mfrc522.uid));
Serial.println();

Ensuite, le code tente d’authentifier un bloc spécifique sur la carte à l’aide de la clé par défaut (dans ce cas, le bloc 2).

// Authenticate the specified block using KEY_A = 0x60
if (mfrc522.PCD_Authenticate(0x60, blockAddress, &key, &(mfrc522.uid)) != 0) {
  Serial.println("Authentication failed.");
  return;
}

Remarque : 0x60 est une commande qui spécifie l’utilisation de KEY_A pour s’authentifier. KEY_A est l’une des deux clés (KEY_A et KEY_B) disponibles sur les cartes RFID, chacune offrant des autorisations différentes. L’utilisation de 0x60 signifie que le code tente de s’authentifier avec KEY_A, qui est par défaut 0xFF 0xFF 0xFF 0xFF 0xFF sur les cartes RFID MIFARE.

Si l’authentification réussit, elle écrit certaines données (enregistrées sur newBlockData) dans ce bloc.

// Write data to the specified block
if (mfrc522.MIFARE_Write(blockAddress, newBlockData, 16) != 0) {
  Serial.println("Write failed.");
} else {
  Serial.print("Data written successfully in block: ");
  Serial.println(blockAddress);
}

Après l’écriture, il lit les données du bloc et les imprime sur le moniteur série.

// Read data from the specified block
if (mfrc522.MIFARE_Read(blockAddress, blockDataRead, &bufferblocksize) != 0) {
  Serial.println("Read failed.");
} else {
  Serial.println("Read successfully!");
  Serial.print("Data in block ");
  Serial.print(blockAddress);
  Serial.print(": ");
  for (byte i = 0; i < 16; i++) {
    Serial.print((char)blockDataRead[i]);  // Print as character
  }
  Serial.println();
}

Enfin, le code interrompt la communication avec la carte et arrête le cryptage.

// Halt communication with the card
mfrc522.PICC_HaltA();
mfrc522.PCD_StopCrypto1();                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              

Tester l’exemple

Dans cet exemple, nous avons stocké les données personnelles suivantes « Rui Santos – RNT » dans le bloc numéro 2 sur deux cartes RFID différentes.

Autres exemples utiles

Il existe quelques exemples fournis avec la bibliothèque Arduino_MFRC522v2 qui pourraient être utiles. Dans le sous-menu Hack, vous pouvez trouver les exemples ChangeUID et FixBrickedUID.

Important : la plupart des cartes RFID ne permettent pas de modifier l’UID. Ce code ne fonctionne que sur des cartes MIFARE Classic spécifiques dotées d’un bloc UID inscriptible. La plupart des cartes RFID ont l’UID défini en lecture seule, donc si vous essayez de modifier l’UID, cela ne fonctionnera pas.

Conclusion

Dans ce guide, vous avez appris à interfacer le module lecteur/enregistreur RFID MFRC522 avec l’ESP8266. Nous avons examiné le fonctionnement du stockage sur les cartes Mifare 1K et comment vider les informations des cartes. Nous avons également appris comment obtenir l’UID de la carte, écrire de nouvelles données sur un bloc spécifique et comment lire les données d’un bloc spécifique.

Nous espérons que vous avez trouvé ce guide pour l’ESP8266 avec lecteur/enregistreur RFID MFRC522 utile. Nous avons un guide similaire pour la carte Arduino :

Si vous souhaitez en savoir plus sur l’ESP8266 et trouver l’inspiration pour de nouveaux projets, n’oubliez pas de consulter nos ressources :

Merci d’avoir lu.

Apprenez l’histoire de Raspberry Pi à travers cette vidéo :