RFID : Contrôle d’accès par badge avec Arduino – RC522

“ Découvrez notre Chaîne YouTube "Ingénierie et Projets"

‘ Découvrez notre Chaîne Secondaire "Information Neuronale et l'Ingénierie du Cerveau"

 Obtenir le fichier PDF

Objectifs
Comprendre le fonctionnement et l’utilité de la technologie RFID
Savoir les caractéristiques techniques du module RFID RC522
Se familiariser à l’utilisation du module RC522 dans un projet du contrôle d’accès
 Se familiariser à l’utilisation de la librairie dédiée au module RC522
Autres astuces pratiques

RFID : Comment ça marche ?

Le présent projet est une introduction à une série des projets qui abordent la technologie RFID. RFID «Radio-Frequency IDentification» est une
technologie pour laquelle les données numériques codées dans des étiquettes RFID ou « tags ». Elles sont capturées par un lecteur via des ondes
radio. La RFID est similaire aux codes barres dans la mesure où les données d’une étiquette sont capturées par un appareil qui stocke les données
dans une base de données. La RFID présente toutefois plusieurs avantages par rapport aux systèmes utilisant un logiciel de suivi des actifs de codes
barres. En effet, le code barre nécessite un scanner optique.

La RFID appartient à un groupe de technologies appelées Automatic Identification and Data Capture (AIDC). Les méthodes AIDC identifient
automatiquement les objets, collectent des données les saisissent directement dans des systèmes informatiques avec une intervention humaine
minime. Les méthodes RFID utilisent des ondes radio pour y parvenir. À un niveau simple, les systèmes RFID se composent de trois composants: une
étiquette RFID « RFID tag », un lecteur RFID et une antenne. Les étiquettes RFID contiennent un circuit intégré et une antenne, qui permettent de
transmettre des données au lecteur RFID. Le lecteur convertit ensuite les ondes radio en une forme de données plus utilisable. Les informations
collectées à partir des étiquettes sont ensuite transférées via une interface de communication vers un système informatique hôte pour les traitements
ultérieurs.

La technologie RFID basée sur des transferts d’énergie par liaison radio en utilisant des antennes électromagnétiques. Pour la mettre en application, il
est nécessaire de disposer de marqueurs (étiquettes, tags ou puces RFID) et d’un lecteur RFID. Lire la suite…

Applications (voir la vidéo en bas de la page)

Gestion de l’inventaire
Suivi des actifs
Suivi du personnel
Contrôle de l’accès aux zones restreintes
Badge d’identification
Gestion de la chaîne logistique
Prévention de la contrefaçon (par exemple dans l’industrie pharmaceutique)
Plus de détails

Tout savoir sur le module RFID RC522 à 13.56MHz

Le module est un lecteur de la puce RFID basé sur le circuit MFRC522 à faible coût est facile à utiliser. Il peut être utilisé dans une large gamme
d’application. Le MFRC522 est un circuit intégré de lecture / écriture hautement intégré pour la communication sans contact à 13,56 MHz. Ci-dessous
les caractéristiques du module:

Basé sur le circuit MFRC522

Fréquence de fonctionnement: 13,56 MHz
Tension d’alimentation: 3.3V
Courant: 13-26mA
Portée de lecture: Environ 3 cm avec la carte et le porte-clés fournis
Interface de communication : SPI
Taux de transfert de données maximum: 10 Mbit / s
Dimensions: 60mm × 39mm
MFRC522 Datasheet

Fonctionnement du projet contrôle d’accès par badge avec Arduino

 RFID-RC522 Arduino
D3 D2

LED LED
Affichage

RS232

100

L’application consiste l’ouverture d’une porte en utilisant un badge. Le lecteur RFID couplé à la carte Arduino permet de détecter un badge enregistré
ou non. Lorsque l’utilisateur est reconnu, le système déclenche l’ouverture de la porte ou une alarme dans le cas échéant. L’utilisateur à droit de trois
tentatives. Le nombre de tentatives est ajustable par le programme Arduino. Ci-dessous les éléments constituant le projet ainsi leurs fonctionnements.

RFID-RC522 : Lecteur du badge

Carte Arduino : Elle est couplée avec le lecteur RFID. Elle permet de détecter la présence du badge, reconnaitre son identifiant (code du badge). Elle
sert également à activer l’ouverture de la porte ou l’alarme

LED verte : Voyant indiquant l’ouverture de la porte. La LED s’allume pendant une seconde lorsqu’un badge reconnu est détecté. Elle reste éteinte dans
le cas contraire

LED rouge : Voyant indiquant la détection d’un Fau badge (identifiant non reconnu du badge). La LED rouge s’allume pendant une seconde puis s’éteint
pour chaque fausse détection. Lorsque le nombre de tentatives est atteint, la LED rouge clignote en boucle infinie en état d’alarme. Aucune moyenne
n’est possible pour réactiver le système à part la réinitialisation de la carte Arduino.

‘ Note : On peut ajouter un bouton de réinitialisation (non lisible pour l’utilisation) dédié à la désactivation de l’alarme.

RS232 : Le système communique l’état de la porte ou la présence de l’alarme par la liaison RS232. On affiche « Ouverture de la porte » lorsque la LED
verte est allumée. Et « Alarme » en boucle lorsque le nombre de tentatives est attient.

Câblage des composants

LED rouge: D2
 LED verte: D3

RFID-ARDUINO:

Signal RFID-RC522 ARDUINO

RST/Reset RST D9

SPI SS SDA(SS) D10

SPI MOSI MOSI D11

SPI MISO MISO D12

SPI SCK SCK D13

Comment lire l’ID d’un badge ?

Le module RFID est accompagné de deux badges de formes différentes (voir l’image ci-dessus) : l’un se forme d’une carte et l’autre d’une clé. Pour
l’instant on ne connaît pas les identifiants de chacun d’entre eux. La première étape consiste à reconnaitre les ID pour les opérations à venir. Nous
avons besoin de télécharger la librairie RFID (disponible ICI). On considère le même schéma de câblage. Ci-dessous les étapes importantes de
déclaration, initialisation, lecture et affichage de l’ID d’un badge.

1- Déclaration

1 #include <SPI.h> // SPI

2 #include <MFRC522.h> // RFID
3
4 #define SS_PIN 10
5 #define RST_PIN 9
6
7 // Déclaration
8 MFRC522 rfid(SS_PIN, RST_PIN);
9
10 // Tableau contentent l'ID
11 byte nuidPICC[4];

2- Initialisation

1 void setup()
2 {
3 // Init RS232
4 Serial.begin(9600);
5
6 // Init SPI bus
7 SPI.begin();
8
9 // Init MFRC522
10 rfid.PCD_Init();
11 }
12

3- Attente d’un nouveau badge

1 void loop()
2 {
3
 3
4 // Initialisé la boucle si aucun badge n'est présent
5 if ( !rfid.PICC_IsNewCardPresent())
6 return;
7
8 // Vérifier la présence d'un nouveau badge
9 if ( !rfid.PICC_ReadCardSerial())
10 return;
11 …
}

4- Enregistrement de l’ID

1 …
2 // Enregistrer l'ID du badge (4 octets)
3 for (byte i = 0; i < 4; i++)
4 {
5 nuidPICC[i] = rfid.uid.uidByte[i];
6 }
7 …

5- Affichage de l’ID

1 …
2 // Affichage de l'ID
3 Serial.println("Un badge est détecté");
4 Serial.println(" L'UID du tag est:");
5 for (byte i = 0; i < 4; i++)
6 {
7 Serial.print(nuidPICC[i], HEX);
8 Serial.print(" ");
9 }
10 Serial.println();
11 …

6- Re-Initialisation RFID

1 ...
2 // Re-Init RFID
3 rfid.PICC_HaltA(); // Halt PICC
4 rfid.PCD_StopCrypto1(); // Stop encryption on PCD
5 ...

7- Programme complet

1 #include <SPI.h> // SPI

2 #include <MFRC522.h> // RFID
3
4 #define SS_PIN 10
5 #define RST_PIN 9
6
7 // Déclaration
8 MFRC522 rfid(SS_PIN, RST_PIN);
9
10 // Tableau contentent l'ID
11
 11
byte nuidPICC[4];
12
13
void setup()
14
{
15
// Init RS232
16
Serial.begin(9600);
17
18
// Init SPI bus
19
SPI.begin();
20
21
// Init MFRC522
22
rfid.PCD_Init();
23
}
24
25
void loop()
26
{
27
// Initialisé la boucle si aucun badge n'est présent
28
if ( !rfid.PICC_IsNewCardPresent())
29
return;
30
31
// Vérifier la présence d'un nouveau badge
32
if ( !rfid.PICC_ReadCardSerial())
33
return;
34
35
// Enregistrer l'ID du badge (4 octets)
36
for (byte i = 0; i < 4; i++)
37
{
38
nuidPICC[i] = rfid.uid.uidByte[i];
39
}
40
41
// Affichage de l'ID
42
Serial.println("Un badge est détecté");
43
Serial.println(" L'UID du tag est:");
44
for (byte i = 0; i < 4; i++)
45
{
46
Serial.print(nuidPICC[i], HEX);
47
Serial.print(" ");
48
}
49
Serial.println();
50
51
// Re-Init RFID
52
rfid.PICC_HaltA(); // Halt PICC
53
rfid.PCD_StopCrypto1(); // Stop encryption on PCD
54
}

Les ID des badges obtenus (voir la vidéo)

Programme du contrôle d’accès par un badge
On reprend les mêmes étapes du programme de lecture. En revanche, on garde en mémoire l’ID du badge {0x20, 0x12, 0x23, 0x2B}. Le programme
compare en permanent le nouvel ID avec l’ID de base. Si les deux ID sont identiques, on déclenche l’ouverture de la porte, sinon l’alarme après trois
tentatives. On fera des tests (voir la vidéo) en utilisant le bon badge ayant le même ID enregistré et un nouveau badge ayant un ID différent. On verra
dans la vidéo une démonstration avec 3 et 4 tentatives. Ci-dessous le programme principal du projet.

Nous utiliserons une nouvelle fonction GetAccesState() qui prend en argument les deux ID (ID enregistré et le nouvel ID), puis elle retourne « 1 » si les
deux ID sont identiques et 0 dans le cas contraire. Les variables à l’entrée sont deux tableaux de tailles 4 aux formats byte (la taille du code est égale à
4 octets). Ci-dessous la déclaration de la fonction :

1 byte GetAccesState(byte *CodeAcces,byte *NewCode)

2 {
3 byte StateAcces=0;
4 if ((CodeAcces[0]==NewCode[0])&&(CodeAcces[1]==NewCode[1])&&
5 (CodeAcces[2]==NewCode[2])&& (CodeAcces[3]==NewCode[3]))
6 return StateAcces=1;
7 else
8 return StateAcces=0;
9 }

Programme principal

1 #include <SPI.h>
2 #include <MFRC522.h>
3
4 #define SS_PIN 10
5 #define RST_PIN 9
6
7 #define AccesFlag_PIN 2
8 #define Gate_PIN 3
9 #define Max_Acces 3
10
11 byte Count_acces=0;
12 byte CodeVerif=0;
13 byte Code_Acces[4]={0x20, 0x12, 0x23, 0x2B};
14
15 MFRC522 rfid(SS_PIN, RST_PIN); // Instance of the class
16
17 // Init array that will store new NUID
18 byte nuidPICC[4];
19
20 void setup()
21 {
22 // Init RS232
23 Serial.begin(9600);
24
25 // Init SPI bus
26 SPI.begin();
27
28 // Init MFRC522
29 rfid.PCD_Init();
30
31 // Init LEDs
32 pinMode(AccesFlag_PIN, OUTPUT);
33 pinMode(Gate_PIN, OUTPUT);
34
35 digitalWrite(AccesFlag_PIN, LOW);
36 digitalWrite(Gate_PIN, LOW);
37 }
38
39 void loop()
40 {
41 // Initialisé la boucle si aucun badge n'est présent
42 if ( !rfid.PICC_IsNewCardPresent())
43 return;
44
45 // Vérifier la présence d'un nouveau badge
46 if ( !rfid.PICC_ReadCardSerial())
47 return;
48
49 // Afffichage
50 Serial.println(F("Un badge est détecté"));
51
52 // Enregistrer l’ID du badge (4 octets)
53 for (byte i = 0; i < 4; i++) {
54 nuidPICC[i] = rfid.uid.uidByte[i];
55 }
56
57 // Vérification du code
58 CodeVerif= GetAccesState(Code_Acces,nuidPICC);
59 if (CodeVerif!=1)
60 {
61 Count_acces+=1;
62 if(Count_acces==Max_Acces)
63 {
64 // Dépassement des tentatives (clignotement infinie)
65 while(1)
66 {
67 digitalWrite(AccesFlag_PIN, HIGH);
68 delay(200);
69 digitalWrite(AccesFlag_PIN, LOW);
70 delay(200);
71 // Affichage
72 Serial.println("Alarme!");
73 }
74 }
75 else
76 {
77 // Affichage
78 Serial.println("Code érroné");
79
80 // Un seul clignotement: Code erroné
81 digitalWrite(AccesFlag_PIN, HIGH);
82 delay(1000);
83 digitalWrite(AccesFlag_PIN, LOW);
84
 84
}
85
}
86
else
87
{
88
// Affichage
89
Serial.println("Ouverture de la porte");
90
91
// Ouverture de la porte & Initialisation
92
digitalWrite(Gate_PIN, HIGH);
93
delay(3000);
94
digitalWrite(Gate_PIN, LOW);
95
Count_acces=0;
96
}
97
98
// Affichage de l'identifiant
99
Serial.println(" L'UID du tag est:");
100
for (byte i = 0; i < 4; i++)
101
{
102
Serial.print(nuidPICC[i], HEX);
103
Serial.print(" ");
104
}
105
Serial.println();
106
107
// Re-Init RFID
108
rfid.PICC_HaltA(); // Halt PICC
109
rfid.PCD_StopCrypto1(); // Stop encryption on PCD
110
}
111
112
byte GetAccesState(byte *CodeAcces,byte *NewCode)
113
{
114
byte StateAcces=0;
115
if ((CodeAcces[0]==NewCode[0])&&(CodeAcces[1]==NewCode[1])&&
116
(CodeAcces[2]==NewCode[2])&& (CodeAcces[3]==NewCode[3]))
117
return StateAcces=1;
118
else
119
return StateAcces=0;
120
}

Téléchargement
RFID: Programme lecteur ID d’un badge
RFID: Programme contrôle d’accès

Photos du projet
Vidéo démonstration
Vidéo: RFID : Contrôle d’accès par badge avec Arduino

RFID | Arduino: Contrôle d'accès par badge avec Arduino #RFID #RC522

Tout les projets microcontrôleur

‘
Nous Soutenir 💌
 ‘ Le blog contient des publicités, elles permettent de financer l'hébergement et maintenir le blog en fonctionnement. Vous
pouvez utiliser adblock pour une lecture sans publicités.

Série GRAFCET

Projets électroniques

Projets Arduino

Série Analyse fréquentielle

Série Drone | Arduino

Nos kITS

Série Capteurs | Détecteurs

Série Arduino

Série Asservissement | Arduino

Série Traitement d’Image

Série Proteus
Série Matlab

Langage C et VHDL pour les débutants

Traitement d’Images avec Matlab

Tout les livres pour les Électroniciens

Kits Arduino
Rejoindre la team des IR

Kits drone

Devenir Ingénieur

YouTube 24 k

Traitement d’Images avec Matlab

Tout les livres pour les Électroniciens

Langage C et VHDL pour les débutants

Besoin d’Aide ?

Projets-FPGA Pour les Électroniciens

Rejoindre Notre chaîne

Rechercher

Rechercher…

ACCUEIL CONTACT À PROPOS NEWSLETTER AVIS VISITEURS ENVOYEZ-NOUS UN FICHIER JE FAIS UN DON NOS LIVRES FAQ CONCOURS

LOGIN

Hestia | Développé par ThemeIsle