Module badge RFID RC522

Le module RFID RC522 lit et écrit les badges sans contact à 13,56 MHz. Il embarque la puce NXP MFRC522 et une antenne en spirale imprimée sur la carte : il suffit d’approcher une carte ou un porte-clés de quelques centimètres pour qu’il en lise le numéro.

C’est le lecteur le plus répandu des projets Arduino. On s’en sert pour ouvrir une porte, pointer les entrées et les sorties, libérer un casier ou reconnaître un porteur à partir du numéro unique de son badge. Il communique en SPI, s’alimente en 3,3 V et se pilote avec la bibliothèque MFRC522.

À quoi sert un lecteur RFID 13,56 MHz ?

• Contrôle d’accès — ouvrir une porte, une gâche ou un portail sur présentation d’un badge autorisé.
• Pointeuse — enregistrer l’heure d’arrivée et de départ de chaque porteur.
• Casiers et cadenas — libérer un compartiment pour un badge donné, et lui seul.
• Fidélité et distributeurs — reconnaître un client, décompter un crédit inscrit sur sa carte.
• Identification d’objets — coller une pastille 13,56 MHz sur un outil, un flacon ou un bac et savoir ce qu’on a en main.
• Apprentissage — un montage court pour comprendre le sans-contact, la SPI et l’anti-collision.

Caractéristiques techniques

Le brochage, broche par broche

Les huit pastilles sont sérigraphiées sur la carte. La colonne de droite donne le raccordement habituel sur un Uno :

Le nom « SDA » trompe tout le monde. Ici, ce n’est pas une ligne de bus I2C malgré le nom : c’est la sélection de composant, celle qu’on voit aussi écrite SS ou CS sur d’autres modules. Le programme la désigne une fois, au moment de créer l’objet du lecteur, et n’y touche plus.

Les broches 11, 12 et 13 de l’Arduino sont celles du matériel SPI. Sur une autre carte, repérez les broches marquées MOSI, MISO et SCK : ce sont les mêmes signaux, à d’autres numéros. Les broches de sélection et de remise à zéro, elles, se choisissent librement, et n’importe quelle broche numérique convient.

L’alimentation en 3,3 V : le seul point qui abîme le module

Le module se nourrit en 3,3 V, et rien d’autre. Le relier au 5 V de l’Arduino abîme la puce : c’est l’erreur qui détruit le plus de RC522, et elle ne pardonne pas. La broche 3,3 V de la carte Uno convient parfaitement, puisque le lecteur consomme moins de 30 mA.

Sur les lignes de données, la puce MFRC522 est un composant 3,3 V. Beaucoup de montages la relient en direct à un Uno et fonctionnent longtemps, mais la pratique prudente est d’abaisser le niveau des lignes que la carte pilote — SCK, MOSI, SDA et RST — avec un simple diviseur de tension ou un adaptateur de niveau. La ligne MISO, elle, part du module vers la carte : elle ne pose aucune question.

Si votre projet est alimenté par une source 5 V extérieure plutôt que par le câble USB, un régulateur 5 V vers 3,3 V donne au lecteur une alimentation propre et largement dimensionnée.

Un microcontrôleur déjà en 3,3 V — ESP32, ESP8266, STM32 — se raccorde quant à lui directement, sans la moindre adaptation.

Ce que le module lit, et ce qu’il ne lit pas

Le RC522 travaille à 13,56 MHz, la bande dite « haute fréquence ». Il reconnaît les cartes et badges ISO/IEC 14443 A : MIFARE Classic en 1 Ko et 4 Ko, MIFARE Ultralight, et les pastilles NTAG. La carte et le badge fournis avec le module appartiennent à cette famille, et leur numéro se lit sans aucun réglage.

En revanche, il ignore totalement les badges 125 kHz — la fréquence des clés de portail et de la plupart des badges d’immeuble, qu’on reconnaît à leur forme de galet moulé. Aucun réglage n’y changera quoi que ce soit : ce sont deux mondes radio différents, et un lecteur 125 kHz ne lit pas une carte 13,56 MHz, pas plus que l’inverse.

Le module ne se contente pas de lire : il écrit aussi dans la mémoire des cartes. Il gère lui-même les trames du protocole, l’anti-collision, la somme de contrôle et le chiffrement des MIFARE Classic. Votre programme, lui, ne s’occupe que de la liaison SPI.

Mini-projet : un contrôle d’accès qui ouvre la porte

Objectif : un badge autorisé fait coller le relais pendant une seconde, allume une LED et déclenche un bip. Un badge inconnu produit un bip court mais ne commande rien. C’est le montage de base d’une gâche électrique, à une réserve près : le relais alimente ici une charge de démonstration, et non une serrure du secteur.

Ce qu’il faut

Le câblage

Le programme

À copier dans l’IDE Arduino après avoir installé la bibliothèque MFRC522, puis à téléverser :

/*
 * Controle d'acces RFID - lecteur RC522
 * Carte : Arduino Uno R3
 * Montage : lecteur RC522, un relais, une LED rouge et un buzzer actif
 *
 * Composants, brochage et fiche complete : www.marocproduits.com
 */

#include "SPI.h"
#include "MFRC522.h"
#include "string.h"

#define PIN_SDA    10   // selection du module (SDA sur le circuit, SS pour la bibliotheque)
#define PIN_RST     9   // remise a zero du module
#define PIN_RELAIS  7   // commande du module relais
#define PIN_LED     6   // LED rouge, par une resistance de 220 ohms
#define PIN_BUZZER  5   // buzzer actif

MFRC522 lecteur(PIN_SDA, PIN_RST);

// Le badge autorise, releve une fois dans le moniteur serie.
// Les quatre octets de l'exemple sont a remplacer par les votres.
byte badgeAutorise[4] = {0xA1, 0xB2, 0xC3, 0xD4};

const char HEXA[] = "0123456789ABCDEF";   // pour afficher les octets en hexadecimal

void afficheUid(byte *octets, byte nombre) {
  for (byte i = 0; i != nombre; i++) {
    Serial.print(HEXA[octets[i] / 16]);
    Serial.print(HEXA[octets[i] % 16]);
    Serial.print(' ');
  }
  Serial.println();
}

void ouvrir() {
  Serial.println("Badge autorise : ouverture");
  digitalWrite(PIN_RELAIS, LOW);    // la plupart des modules relais collent sur un niveau BAS
  digitalWrite(PIN_LED, HIGH);
  digitalWrite(PIN_BUZZER, HIGH);
  delay(1200);
  digitalWrite(PIN_RELAIS, HIGH);   // relais relache
  digitalWrite(PIN_LED, LOW);
  digitalWrite(PIN_BUZZER, LOW);
  delay(300);                       // le temps de retirer le badge
}

void setup() {
  pinMode(PIN_RELAIS, OUTPUT);
  pinMode(PIN_LED, OUTPUT);
  pinMode(PIN_BUZZER, OUTPUT);

  digitalWrite(PIN_RELAIS, HIGH);   // porte verrouillee au demarrage
  digitalWrite(PIN_LED, LOW);
  digitalWrite(PIN_BUZZER, LOW);

  Serial.begin(9600);
  SPI.begin();
  lecteur.PCD_Init();

  Serial.println("Presentez un badge devant le lecteur.");
}

void loop() {
  // Rien a faire tant qu'aucun badge n'approche du lecteur
  if (lecteur.PICC_IsNewCardPresent() == false) {
    return;
  }
  if (lecteur.PICC_ReadCardSerial() == false) {
    return;
  }

  Serial.print("UID du badge : ");
  afficheUid(lecteur.uid.uidByte, lecteur.uid.size);

  if (memcmp(lecteur.uid.uidByte, badgeAutorise, 4) == 0) {
    ouvrir();
  } else {
    Serial.println("Badge inconnu, acces refuse");
    digitalWrite(PIN_BUZZER, HIGH);
    delay(150);
    digitalWrite(PIN_BUZZER, LOW);
  }

  lecteur.PICC_HaltA();     // la conversation avec ce badge est terminee
  delay(300);
}

Relever le numéro de votre badge

Le programme compare le badge présenté aux quatre octets écrits dans badgeAutorise, qui sont des valeurs d’exemple. Ouvrez le moniteur série à 9600 bauds, présentez votre badge : son numéro s’affiche. Recopiez-le à la place des quatre valeurs d’exemple, en respectant l’écriture 0x devant chaque octet, puis téléversez une nouvelle fois.

Tant que le numéro n’est pas le bon, le montage refuse l’accès : c’est le comportement attendu, et non une panne. Un numéro de badge compte quatre octets ; la bibliothèque en accepte jusqu’à dix, mais quatre suffisent largement sur les cartes et les porte-clés du commerce.

Comment ça marche

• PICC_IsNewCardPresent() vérifie qu’un badge est posé dans le champ, et PICC_ReadCardSerial() remplit lecteur.uid avec son numéro. Ces deux appels font tout le travail radio à votre place.
• afficheUid découpe chaque octet en deux avec une division et un reste par 16, puis lit les deux caractères dans la table HEXA. Les octets s’affichent donc toujours sur deux chiffres, ce qui rend la copie du numéro plus sûre.
• memcmp compare les quatre octets lus aux quatre octets autorisés. Un seul octet différent et l’accès est refusé.
• Le sens du relais. Beaucoup de modules relais collent sur un niveau bas, d’autres sur un niveau haut. Si votre relais fait l’inverse de ce qu’attend le programme, échangez LOW et HIGH : aucun composant n’est en cause.
• PICC_HaltA() termine proprement la conversation, et la courte pause finale évite de lire le même badge des dizaines de fois par seconde.

Points d’attention

• Ne posez pas le lecteur sur du métal. L’antenne est imprimée sur la carte, tout près d’une surface conductrice elle se désaccorde et la portée s’effondre. Prévoyez quelques centimètres d’air sous la carte, ou intercalez un support isolant.
• Les barrettes restent à souder. Les huit pastilles du module sont libres, et les barrettes de broches sont fournies à part : sans soudure, aucun fil ne tient. Soudez la barrette sur les pastilles, côté cuivre opposé à l’antenne, avant de câbler quoi que ce soit.
• Deux lecteurs sur un même bus. C’est possible, chacun ayant sa propre broche de sélection, mais évitez de placer les deux antennes face à face : deux champs à 13,56 MHz qui se recouvrent se brouillent mutuellement.
• Un numéro de badge se copie. L’identifiant lu est un simple numéro de série, qu’une pastille vierge peut reproduire. C’est parfait pour un projet, un prototype ou un montage familial, mais ce n’est pas un système de sécurité à proprement parler. Pour un accès sensible, il faut une autre famille de cartes, dotée d’une authentification réelle, et un lecteur qui la prend en charge.
• Le badge porte-clés se lit de plus près que la carte. Sa bobine est petite : comptez deux à trois centimètres, contre quatre à cinq pour une carte au format carte de crédit.

Questions fréquentes

Le module ne répond pas, par où commencer ?

Vérifiez dans cet ordre : le 3,3 V présent sur la broche d’alimentation, la masse commune avec l’Arduino, la broche SDA bien sur D10, la barrette réellement soudée sur les pastilles, et la bibliothèque MFRC522 installée. La petite LED du module doit s’allumer dès la mise sous tension ; si elle reste éteinte, le problème est dans l’alimentation, pas dans le programme.

Est-ce qu’il reconnaît un badge d’immeuble ou une clé de portail ?

Non, dans la grande majorité des cas. Ces badges travaillent à 125 kHz, et le RC522 lit uniquement le 13,56 MHz. Aucune bibliothèque, aucun réglage et aucune astuce ne font franchir cette limite : c’est une question de fréquence radio.

Quelle distance de lecture attendre ?

Jusqu’à cinq centimètres environ dans de bonnes conditions, carte bien à plat au-dessus de l’antenne. Comptez moins avec un badge porte-clés, et beaucoup moins si le lecteur est posé sur une surface métallique ou si une main couvre le badge.

Puis-je le brancher sur la sortie 5 V de l’Arduino ?

Non. Le module demande 3,3 V : la sortie 5 V l’abîme. La broche 3,3 V de la carte Uno fournit largement les quelques milliampères nécessaires. Seules les lignes de données tolèrent, en pratique, un microcontrôleur en 5 V.

Peut-on autoriser plusieurs badges ?

Oui. Le programme de cette page n’en déclare qu’un pour rester court, mais rien n’empêche d’en autoriser autant que nécessaire : une table de quatre octets par badge, et une boucle qui la parcourt. Sur une carte Uno, la mémoire disponible en accepte des dizaines sans difficulté.

Faut-il forcément un Arduino ?

Non. Le module se pilote avec n’importe quel microcontrôleur doté d’une liaison SPI en 3,3 V : ESP32, ESP8266, STM32, ou un Raspberry Pi dont les entrées-sorties sont justement en 3,3 V.

À combiner avec

Une carte en 3,3 V comme la carte WeMos avec WiFi se raccorde au RC522 sans aucune adaptation de niveau, et permet d’envoyer chaque passage vers un serveur ou une messagerie. Sans réseau à proximité, le lecteur de carte mémoire écrit le journal des passages sur une carte micro SD, que vous dépouillez tranquillement ensuite.

Pour afficher le nom du porteur plutôt que son numéro, un afficheur LCD 16 par 2 en I2C ne réclame que quatre fils et se partage sans difficulté avec le lecteur. Et si vous voulez exiger un badge et un code pour les porteurs occasionnels, un clavier matriciel de 16 touches complète parfaitement le montage.