Ouvrir sa porte de chambre avec un badge grâce à Arduino.

Niveau ★★★ : Intermédiaire

Un bip, un petit voyant vert, et la porte s’ouvre. Comme dans les chambres d’hôtel… sauf qu’ici, c’est la porte de votre chambre, et c’est vous qui avez tout fabriqué.

Dans ce deuxième projet du Lab Maker, une carte Arduino Uno R4 WiFi commande un aimant qui tient la porte fermée. Vous passez votre badge, l’aimant lâche, vous entrez. Et si vous avez oublié le badge sur la table, votre téléphone fait l’affaire.

Je vous emmène pas à pas : comment ça marche, ce qu’il faut acheter et combien ça coûte ici au Cameroun, le câblage fil par fil, le code complet, les tests, puis la pose sur la porte.

Petite précision avant de commencer : je n’ai pas encore installé ce système sur une vraie porte. Le code compile et le câblage a été vérifié sur le papier, mais le premier essai, c’est vous qui le ferez. Je vous explique plus bas comment le faire sans risque.

1. Le principe : un aimant qui tient la porte

Ce qui surprend souvent, c’est que le badge n’ouvre rien du tout. Il donne juste un ordre à la carte : « coupe le courant de l’aimant pendant 5 secondes ».

Cet aimant, c’est une ventouse électromagnétique, le même système que sur les portes vitrées des banques et des bureaux. Un boîtier se visse en haut du cadre, côté chambre, et une plaque de fer se visse en face, sur la porte. Tant que la ventouse reçoit du courant, elle colle la plaque et la porte ne bouge pas. Quand la carte coupe le courant, la plaque se décolle : vous poussez, vous entrez. Cinq secondes plus tard, le courant revient, et la porte se rebloque dès que vous la refermez.

Côté couloir, on ne voit que le lecteur de badges. Tout le reste (la carte, le relais, l’aimant, les fils) est dans la chambre, hors de portée. Votre poignée, votre serrure et votre clé restent à leur place : le système s’ajoute à la porte, il ne la remplace pas. Le jour où vous déménagez, vous dévissez tout sans rien abîmer.

On aurait pu faire autrement. Une gâche électrique, encastrée dans le cadre, est plus discrète, mais il faut entailler le bois. Le petit verrou électrique à languette, lui, est fait pour une armoire, pas pour une porte : en cas de coupure, il resterait fermé, avec vous derrière. Pour une porte déjà posée, l’aimant reste le choix le plus simple.

2. Pourquoi la fabriquer soi-même ?

Je préfère être franc : des serrures à badge ou à code, ça se vend déjà, et ça se pose plus vite qu’un montage Arduino. Je n’ai pas comparé leurs prix pour cet article, alors regardez de votre côté avant de vous décider.

Si vous fabriquez celle-ci, ce n’est pas pour gagner du temps. C’est pour comprendre ce qui se passe à l’intérieur. En chemin, vous apprenez à lire un badge RFID, à commander un relais et à faire afficher une page web par une carte. Ce sont exactement les mêmes briques que pour un portail, une armoire de matériel ou la porte d’un local.

Il y a d’autres avantages. Toutes les pièces sont standard : si le lecteur lâche un jour, vous changez le lecteur, pas tout le système. C’est vous qui décidez qui entre, combien de temps la porte reste libre et quel code ouvre depuis le téléphone. Et quand le projet aura fait son temps, la carte et le lecteur serviront ailleurs.

Ce qu’il faut savoir avant de se lancer

Ce système a aussi ses limites, et je préfère vous les dire tout de suite.

Il faut toujours pouvoir sortir. Le bouton de sortie, à l’intérieur, n’est pas une option. Il coupe l’aimant directement, sans passer par la carte, donc il marche même si elle plante.
Sans courant, la porte est libre. Avec les délestages, c’est important : une coupure ne vous enfermera jamais, mais elle ne protège pas non plus la chambre.
Un aimant n’est pas une serrure. Il tient la porte au quotidien. Pour la nuit ou quand vous partez, fermez aussi à clé.
Changez le mot de passe du Wi-Fi et le code PIN dans le code avant d’installer quoi que ce soit.
Le 12 V ne donne pas de décharge, mais un court-circuit fait chauffer les fils. Fermez le boîtier et gardez les enfants loin du montage ouvert.
Dans une chambre louée ou un local qui reçoit du public, demandez d’abord l’accord du propriétaire.

Le badge pour le confort de tous les jours, la clé pour la sécurité surtout avec les délestages : on garde le meilleur des deux.

Est-ce que ça vaut le coût ?

Comptez environ 59 000 FCFA de pièces, sans le transport de la carte depuis la Chine, le boîtier et la goulotte. La ventouse, à elle seule, représente plus de la moitié de ce budget. Soyons clairs : si votre seul but est de fermer votre chambre, votre serrure et votre clé le font déjà, et gratuitement.

Le montage devient intéressant dans d’autres cas. Quand plusieurs personnes doivent entrer, dans une colocation, un petit bureau ou un atelier : un badge se donne et se retire en changeant une ligne du code, alors qu’une clé se fait copier au marché en dix minutes. Quand vous voulez ouvrir avec votre téléphone, ou plus tard recevoir une alerte à chaque passage. Ou tout simplement quand vous voulez apprendre, ou montrer à des élèves, comment fonctionne un contrôle d’accès.

Ventouse ou gâche électrique ?

La gâche électrique est l’autre grande façon de commander une porte. Bonne nouvelle : si vous la préférez, le reste du projet ne change pas. Carte, lecteur, relais, code : tout est identique, seule la pièce qui bloque la porte change.

	Ventouse (notre choix)	Gâche électrique simple
Pose	Vissée en haut du cadre, sans rien entailler	Encastrée dans le cadre à la place de la gâche d’origine : il faut entailler le bois
Discrétion	Visible en haut de la porte	Presque invisible
Pour sortir	Bouton de sortie obligatoire	La poignée intérieure suffit
Côté couloir	Rien à changer	La poignée extérieure doit être remplacée par un bouton fixe, sinon elle ouvre la porte sans badge
Coupure de courant	Porte libre	Selon le modèle : libre (gâche « à rupture ») ou bloquée (gâche « à émission »)
Consommation	Alimentée en permanence	Gâche à émission : seulement pendant l’ouverture
Borne du relais	NC	NC pour une gâche à rupture, NO pour une gâche à émission

Mon conseil : pour une porte déjà posée que vous ne voulez pas abîmer, prenez la ventouse. Pour un montage discret et définitif, la gâche fait très bien l’affaire, sans toucher au code.

3. Le matériel et ce qu’il coûte

J’ai relevé les prix le 9 novembre 2026 dans quatre boutiques en ligne au Cameroun : komtech.app, KAMEU SHOPs, Now Tech Center et Secure Tech. Les prix bougent vite, vérifiez-les avant d’acheter.

Une seule pièce manquait ce jour-là : la carte Uno R4 WiFi. Aucune des quatre boutiques ne la proposait. Je l’ai trouvée sur Taobao, en Chine, à 92,1 yuans, soit environ 8 100 FCFA au taux du jour, plus les frais de port, qui dépendent de votre transitaire. Il existe une version moins chère à 70,55 yuans (environ 6 200 FCFA), mais de moins bonne qualité. Pour une porte qui doit marcher tous les jours, je prendrais la bonne.

Pièce	Qté	Rôle	Prix (FCFA)	Boutique
Arduino Uno R4 WiFi (USB-C)	1	Le cerveau, avec le Wi-Fi intégré	environ 8 100 (92,1 ¥), plus les frais de port selon le transitaire	Taobao
Module RFID RC522	1	Le lecteur, qui lit le numéro du badge	4 000	komtech.app
Ventouse électromagnétique 12 V avec support (ZKTeco AL-280, 280 kg)	1	Tient la porte tant qu’elle est alimentée	34 900	Now Tech Center
Module relais 5 V (contacts 10 A)	1	L’interrupteur qui coupe le courant de l’aimant	1 000	komtech.app
Bouton de sortie « EXIT » (contacts NO/NC)	1	Pour sortir de l’intérieur (on câble le contact NC)	5 000	Secure Tech
Diode 1N4007	1	Protège le relais	100	KAMEU SHOPs
Adaptateur secteur 12 V, 2 A	1	Alimente tout le montage	3 500	komtech.app
Prise jack DC 5,5 × 2,1 mm (mâle + femelle)	1 paire	Partage le 12 V entre la carte et l’aimant	500	komtech.app
LED 5 mm, une verte et une rouge	2	Les voyants, à côté du lecteur	40 (20 l’unité, lot de 100 à 2 000)	KAMEU SHOPs
Résistance 220 Ω	2	Limitent le courant des LED	20 (10 l’unité, lot de 10 à 100)	KAMEU SHOPs
Buzzer actif 5 V	1	Les bips	250	komtech.app
Transistor 2N2222	1	Commande le buzzer	100	KAMEU SHOPs
Résistance 1 kΩ (1 W)	1	Sur la base du transistor	500	KAMEU SHOPs
Fils Dupont (40 brins)	1 lot	Les connexions	1 000	komtech.app
Boîtier plastique, goulotte	—	Le montage propre	à voir sur place	quincaillerie
Total (sans les frais de port de la carte, le boîtier et la goulotte)			environ 59 000

Deux pièces demandent un peu d’attention au moment de l’achat.

Le bouton de sortie doit couper le courant quand on appuie dessus. Les boutons « EXIT » vendus pour le contrôle d’accès ont trois bornes, COM, NO et NC, et c’est COM et NC qu’on branche : au repos le courant passe, et quand on appuie, il est coupé. Un simple bouton poussoir « normalement ouvert » ne marchera pas ici.

Le buzzer doit être actif : il sonne tout seul dès qu’il reçoit du courant. Avec ce code, un buzzer passif ne ferait qu’un petit clic.

Pourquoi une Uno R4 WiFi ?

Si vous avez suivi le Projet 01, vous connaissez déjà l’Arduino Uno. La Uno R4 WiFi, c’est la même forme, les mêmes broches et le même logiciel, avec le Wi-Fi intégré et une prise USB-C en plus.

Trois choses la rendent idéale ici. Son Wi-Fi permet d’ouvrir la porte avec le téléphone, sans ajouter de module. Sa prise jack accepte de 6 à 24 V, donc le même adaptateur 12 V alimente la carte et l’aimant. Et comme son alimentation passe par un régulateur à découpage, elle reste à peine tiède en 12 V, là où l’ancienne Uno chauffait. Vérifiez quand même ces valeurs sur la fiche de votre carte.

4. Le câblage, broche par broche

Voici deux images du même câblage. La première montre les vraies pièces et où arrive chaque fil ; le 5 V et le GND passent par une petite plaque d’essai. La seconde est un schéma, moins joli mais plus pratique pour vérifier chaque broche une à une. Gardez-le ouvert à côté de vous pendant le montage.

Les broches D11, D12 et D13 sont celles du bus SPI : elles sont imposées par la carte. Toutes les autres, je les ai choisies. Vous pouvez en changer, il suffit de modifier une ligne en haut du code.

Élément	Sa broche	Broche de la Uno R4 WiFi
Lecteur RC522	SDA (SS)	D10
Lecteur RC522	SCK	D13 (fixe)
Lecteur RC522	MOSI	D11 (fixe)
Lecteur RC522	MISO	D12 (fixe)
Lecteur RC522	RST	D9
Lecteur RC522	3.3V	3.3V (jamais sur 5 V)
Lecteur RC522	GND	GND
Relais	S	D7
Relais	+ / –	5V / GND
LED verte	+ (via 220 Ω)	D4
LED rouge	+ (via 220 Ω)	D5
Buzzer	via le transistor (base ← 1 kΩ)	D6

Quelques détails de ce tableau méritent qu’on s’y arrête.

Le buzzer ne se branche pas directement sur la carte, il passe par un transistor. D6 va à la résistance de 1 kΩ, puis à la base du transistor. L’émetteur va au GND, le collecteur au – du buzzer, et le + du buzzer au 5V.

Le lecteur RC522 travaille en 3,3 V : branché sur le 5 V, il risque de griller. Ses broches de données, elles, reçoivent les signaux de la carte en 5 V. Beaucoup de montages fonctionnent ainsi sans souci, mais un petit convertisseur de niveaux entre la carte et le lecteur (sur D9, D10, D11 et D13) rend le tout plus sûr.

Sur le relais, les bornes COM, NC et NO ne sont pas toujours marquées. Repérez-les au multimètre, en mode continuité. Ici, la borne NO ne sert pas.

Et le bouton de sortie ? Vous ne le trouverez pas dans le tableau, et c’est normal : il n’est pas relié à la carte. Il est sur le fil de l’aimant, comme on va le voir.

Le côté puissance : un seul adaptateur 12 V pour tout

Un adaptateur 12 V de 2 A suffit largement. L’aimant consomme environ 0,25 à 0,5 A, la carte et ses modules environ 0,3 A.

L’adaptateur se branche dans la prise jack femelle à bornes à vis : c’est elle qui fait le « partage ».
De ce partage, une paire de fils va vers la prise jack mâle, branchée dans la carte. La carte fournit ensuite le 5 V (relais, buzzer) et le 3,3 V (lecteur).
Une autre paire de fils part vers l’aimant, en passant d’abord par le bouton de sortie, puis par le relais :
- le + de l’adaptateur va au bouton de sortie (NF) ;
- le bouton va à la borne COM du relais ;
- la borne NC du relais va au + de l’aimant ;
- le – de l’aimant revient au – de l’adaptateur.
La diode 1N4007 se branche directement sur les deux bornes de l’aimant, à l’envers : sa bague (la cathode) du côté du +.

Pourquoi la borne NC, « normalement fermée » ? Parce qu’au repos, le relais laisse passer le courant et l’aimant tient la porte. Le relais ne travaille que pendant les 5 secondes d’ouverture, le reste du temps il se repose.

L’adaptateur peut rester sur la prise la plus proche, même à quelques mètres : jusqu’à 5 à 10 m, du fil de 0,5 à 0,75 mm² suffit. Et non, un chargeur de téléphone ne fera pas l’affaire : il donne 5 V, et la ventouse veut du 12 V.

Attention : ne branchez jamais la ventouse ni le relais directement sur une broche de la carte : une broche ne fournit que quelques dizaines de milliampères. Le 12 V de la ventouse passe uniquement par les contacts du relais, avec ses propres fils. Vérifiez deux fois le sens de la diode, et ne branchez l’adaptateur qu’à la toute fin.

5. Le code

Le programme tourne en boucle et se pose sans arrêt deux questions : est-ce qu’un badge est posé sur le lecteur ? Est-ce que quelqu’un a envoyé le code depuis son téléphone ? Dans les deux cas, il décide d’ouvrir ou de refuser.

Ouvrir avec son téléphone : deux façons

La carte affiche une petite page web avec un champ « Code ». Vous tapez votre code PIN, vous appuyez sur « Ouvrir », et c’est tout. Il reste à choisir comment le téléphone rejoint la carte, et ça se règle sur une seule ligne du code : CREER_MON_RESEAU.

	A · Directement sur la carte	B · Par le modem de la maison
Réglage	`CREER_MON_RESEAU = true`	`CREER_MON_RESEAU = false`
Comment	La carte crée son propre réseau Wi-Fi (« Porte-Chambre »), le téléphone s’y connecte	La carte et le téléphone se connectent au même modem
Adresse de la page	Affichée dans le moniteur série (en principe 192.168.4.1)	Affichée dans le moniteur série
Avantages	Pas besoin de modem ni d’internet	Le téléphone garde internet, portée de toute la maison
Limites	Il faut être à moins de 10 à 20 m ; le téléphone perd internet pendant la connexion	Il faut le modem allumé ; un délestage l’éteint aussi

Quelle que soit la façon choisie, trois codes faux d’affilée bloquent la page pendant 30 secondes, de quoi décourager celui qui tenterait sa chance au hasard. Et si le Wi-Fi refuse de démarrer, le badge continue de marcher normalement.

Avant de téléverser

Dans l’IDE Arduino, installez le paquet de cartes « Arduino UNO R4 Boards », puis choisissez la carte « Arduino UNO R4 WiFi ».
Installez la bibliothèque MFRC522 (GithubCommunity). La bibliothèque WiFiS3 est déjà fournie avec la carte. À la compilation, l’IDE vous dira que MFRC522 est « peut-être incompatible » avec la carte (renesas_uno) : pas de panique, c’est un simple avertissement, il ne bloque rien.
Téléversez le code, ouvrez le moniteur série (115200 bauds) et passez vos badges un par un : leur numéro s’affiche sous la forme {0x.., 0x.., ...}. Copiez-les dans la liste badges, puis téléversez à nouveau.
Changez RESEAU_CARTE_MDP (le mot de passe du Wi-Fi) et CODE_PIN.

Comment lire ce code

Nous avons structuré ce code avec l’aide d’une IA (Claude) afin d’avoir un code propre et assez commenté, puis nous l’avons compilé sans erreur dans l’IDE Arduino. Nous avons insisté sur un point : qu’on puisse le lire et le comprendre sans être un expert. Il est découpé en six parties numérotées, et vous n’aurez à toucher qu’à la première, « Réglages », tout en haut.

Mon conseil : commencez la lecture par la fin, par la fonction loop(). En quelques lignes, elle raconte tout le fonctionnement.

void loop() {
  if (badgePresente()) {
    if (badgeAutorise()) deverrouiller();
    else                 refuser();
    finLectureBadge();
  }

  int web = lireDemandeWeb();
  if (web == WEB_CODE_BON)  deverrouiller();
  if (web == WEB_CODE_FAUX) refuser();
}

On badge. On regarde s’il est dans la liste, puis on ouvre ou on refuse. Le téléphone a envoyé un code ? Même chose. Badge ou téléphone, c’est toujours la même fonction deverrouiller() qui ouvre la porte.

Ensuite, chaque fonction a un seul rôle :

deverrouiller() allume le voyant vert, fait un bip, coupe l’aimant 5 secondes, puis le rallume. Si la porte est restée fermée, elle se rebloque aussitôt. Si vous l’avez ouverte, l’aimant ne retient rien et reprend la plaque quand vous refermez.
refuser() allume le voyant rouge et fait trois bips.
badgePresente() détecte un badge, lit son numéro et l’affiche dans le moniteur série. badgeAutorise() compare ce numéro à votre liste.
lireDemandeWeb() répond au téléphone. Elle envoie toujours la page avant que la porte s’ouvre, pour que vous voyiez s’afficher « Code correct ».
setup() bloque la porte en tout premier, pour qu’elle ne soit jamais libre par erreur au démarrage.

Dans les réglages, deux lignes méritent votre attention. RELAIS_ACTIF vaut HIGH : si votre relais fait l’inverse de ce qu’on attend, mettez LOW. TEMPS_OUVERTURE vaut 5000 millisecondes ; si 5 secondes vous semblent courtes, passez à 8000.

La liste badges contient deux numéros d’exemple, à remplacer par les vôtres. Ce code accepte les badges dont le numéro fait 4 octets, ceux qu’on trouve avec le RC522. Un badge de 7 octets serait refusé.

Un dernier détail : pendant les 5 secondes d’ouverture, la carte attend et ne lit plus rien. C’est voulu, pour garder un code simple.

Comme tout le projet, ce code n’a pas encore tourné sur un vrai montage : faites vos premiers essais avec la ventouse débranchée. Voici le code complet.

/*
  ================================================================
  PROJET 02 — PORTE DE CHAMBRE À BADGE RFID                ★★☆
  Kennedyen.net — Le Lab Maker — « Comprendre, tester, réussir. »
  ================================================================
  Carte    : Arduino Uno R4 WiFi (alimentée en 12 V par sa prise jack)
  Lecteur  : RC522 (bus SPI)
  Verrou   : ventouse électromagnétique 12 V
             (porte bloquée tant qu'elle est alimentée,
              libre quand le courant est coupé)
  Bibliothèque à installer : MFRC522 (GithubCommunity)
  (WiFiS3 est déjà fournie avec la carte R4)

  En deux mots :
  - Au repos, la ventouse est alimentée : la porte est BLOQUÉE.
  - Badge autorisé OU bon code sur la page web : la carte coupe le
    courant de la ventouse pendant 5 secondes, puis le remet.
  - Le bouton de sortie (à l'intérieur) ne passe pas par la carte :
    il marche même si la carte est en panne.

  Astuce : chaque badge lu est affiché dans le moniteur série
  sous la forme {0x.., 0x.., ...} -> copiez-le dans la liste
  « badges » plus bas.
  ================================================================
*/

#include <SPI.h>
#include <MFRC522.h>
#include <WiFiS3.h>


// ================================================================
//  1. RÉGLAGES (c'est ici, et seulement ici, que vous modifiez)
// ================================================================

// ----- Broches -----
// Le RC522 utilise aussi D11 (MOSI), D12 (MISO) et D13 (SCK) : broches fixes.
#define PIN_SS          10   // SDA du RC522
#define PIN_RST         9    // RST du RC522
#define PIN_AIMANT      7    // commande du relais qui coupe l'aimant
#define PIN_LED_VERTE   4
#define PIN_LED_ROUGE   5
#define PIN_BUZZER      6    // via un transistor (voir le câblage)

// ----- Relais -----
#define RELAIS_ACTIF    HIGH   // mettre LOW si votre relais s'active à l'état bas
const unsigned long TEMPS_OUVERTURE = 5000;   // porte libre pendant 5 s

// ----- Wi-Fi -----
// true  : la carte crée son propre réseau (pas besoin de modem)
// false : la carte se connecte au modem de la maison
const bool CREER_MON_RESEAU = true;
const char* RESEAU_CARTE_NOM = "Porte-Chambre";
const char* RESEAU_CARTE_MDP = "ChangezMoi8";    // 8 caractères minimum !
const char* MODEM_NOM = "NomDeVotreModem";       // utilisé si CREER_MON_RESEAU = false
const char* MODEM_MDP = "MotDePasseModem";

// ----- Code de la page web (à changer !) -----
const char* CODE_PIN = "1234";

// ----- Badges autorisés (UID de 4 octets) -----
// Posez un badge, lisez son UID dans le moniteur série, copiez-le ici.
const byte badges[][4] = {
  {0xDE, 0xAD, 0xBE, 0xEF},   // Badge 1 (à remplacer)
  {0xCA, 0xFE, 0xBA, 0xBE},   // Badge 2 (à remplacer)
};
const int NB_BADGES = sizeof(badges) / sizeof(badges[0]);


// ================================================================
//  2. OBJETS ET VARIABLES (rien à modifier)
// ================================================================
MFRC522 rfid(PIN_SS, PIN_RST);
WiFiServer serveur(80);
bool wifiPret = false;

// Résultats possibles d'une demande envoyée par la page web
const int WEB_RIEN       = 0;   // personne n'a envoyé de code
const int WEB_CODE_BON   = 1;
const int WEB_CODE_FAUX  = 2;

// Protection contre les essais au hasard : 3 erreurs = 30 s de blocage
int erreursDeCode = 0;
unsigned long blocageJusqua = 0;


// ================================================================
//  3. ACTIONS : la porte, les LED, le buzzer
// ================================================================
void bloquerPorte() {                       // ventouse alimentée
  digitalWrite(PIN_AIMANT, RELAIS_ACTIF == HIGH ? LOW : HIGH);
}

void libererPorte() {                       // ventouse sans courant
  digitalWrite(PIN_AIMANT, RELAIS_ACTIF);
}

void bip(int duree) {
  digitalWrite(PIN_BUZZER, HIGH);
  delay(duree);
  digitalWrite(PIN_BUZZER, LOW);
}

// Accès accepté : LED verte, un bip, porte libre 5 s, puis on rebloque.
// Au bout des 5 s, le courant revient toujours dans la ventouse :
//  - porte restée fermée      -> elle se rebloque (voulu : jamais oubliée ouverte)
//  - porte ouverte, on entre  -> la ventouse ne retient rien ; elle reprend
//                                la plaque quand on referme la porte
//  - on tire encore dessus    -> la porte résiste : repassez le badge
//                                (augmentez TEMPS_OUVERTURE si 5 s sont trop courts)
void deverrouiller() {
  digitalWrite(PIN_LED_VERTE, HIGH);
  bip(120);
  libererPorte();
  delay(TEMPS_OUVERTURE);
  bloquerPorte();
  digitalWrite(PIN_LED_VERTE, LOW);
}

// Accès refusé : LED rouge, trois bips, la porte reste bloquée
void refuser() {
  digitalWrite(PIN_LED_ROUGE, HIGH);
  for (int i = 0; i < 3; i++) {
    bip(80);
    delay(80);
  }
  delay(600);
  digitalWrite(PIN_LED_ROUGE, LOW);
}


// ================================================================
//  4. LE BADGE
// ================================================================

// Y a-t-il un badge posé sur le lecteur ? (si oui, on le lit et on l'affiche)
bool badgePresente() {
  if (!rfid.PICC_IsNewCardPresent()) return false;
  if (!rfid.PICC_ReadCardSerial())   return false;

  Serial.print("Badge lu : {");
  for (byte i = 0; i < rfid.uid.size; i++) {
    Serial.print("0x");
    if (rfid.uid.uidByte[i] < 0x10) Serial.print("0");
    Serial.print(rfid.uid.uidByte[i], HEX);
    if (i < rfid.uid.size - 1) Serial.print(", ");
  }
  Serial.println("}");
  return true;
}

// Ce badge est-il dans la liste ?
bool badgeAutorise() {
  if (rfid.uid.size != 4) return false;     // la liste ne contient que des UID de 4 octets
  for (int i = 0; i < NB_BADGES; i++) {
    if (memcmp(rfid.uid.uidByte, badges[i], 4) == 0) {
      Serial.println("Badge autorisé.");
      return true;
    }
  }
  Serial.println("Badge refusé.");
  return false;
}

// On a fini avec ce badge : on attend le suivant
void finLectureBadge() {
  rfid.PICC_HaltA();
  rfid.PCD_StopCrypto1();
}


// ================================================================
//  5. LA PAGE WEB (ouverture depuis le téléphone)
// ================================================================
void demarrerWifi() {
  if (CREER_MON_RESEAU) {
    // La carte crée son réseau : le téléphone s'y connecte directement
    int etat = WiFi.beginAP(RESEAU_CARTE_NOM, RESEAU_CARTE_MDP);
    if (etat != WL_AP_LISTENING) {
      Serial.println("Échec du réseau Wi-Fi (le badge marche quand même).");
      return;
    }
    delay(2000);
  } else {
    // La carte rejoint le modem de la maison (4 essais maximum)
    Serial.print("Connexion au modem");
    for (int essai = 0; essai < 4 && WiFi.status() != WL_CONNECTED; essai++) {
      WiFi.begin(MODEM_NOM, MODEM_MDP);
      delay(5000);
      Serial.print(".");
    }
    Serial.println();
    if (WiFi.status() != WL_CONNECTED) {
      Serial.println("Pas de connexion au modem (le badge marche quand même).");
      return;
    }
  }

  serveur.begin();
  wifiPret = true;
  Serial.print("Page web : http://");
  Serial.println(WiFi.localIP());
}

// Envoie la page avec le champ « Code » et un message
void envoyerPage(WiFiClient &client, const char* message) {
  client.println("HTTP/1.1 200 OK");
  client.println("Content-Type: text/html; charset=utf-8");
  client.println("Connection: close");
  client.println();
  client.println("<!DOCTYPE html><html><head>");
  client.println("<meta name='viewport' content='width=device-width,initial-scale=1'>");
  client.println("<style>body{font-family:sans-serif;text-align:center;background:#0b1220;color:#fff;padding:30px}");
  client.println("input,button{font-size:22px;padding:12px;margin:8px;border-radius:8px;border:0}");
  client.println("button{background:#16a34a;color:#fff}</style></head><body>");
  client.println("<h2>Ma porte</h2>");
  client.print("<p>");
  client.print(message);
  client.println("</p>");
  client.println("<form action='/ouvrir' method='get'>");
  client.println("<input name='pin' type='password' inputmode='numeric' placeholder='Code'><br>");
  client.println("<button>Ouvrir</button></form>");
  client.println("</body></html>");
}

// Regarde si le téléphone a envoyé quelque chose.
// Renvoie WEB_RIEN, WEB_CODE_BON ou WEB_CODE_FAUX.
// (La page est toujours envoyée AVANT que la porte s'ouvre.)
int lireDemandeWeb() {
  if (!wifiPret) return WEB_RIEN;

  WiFiClient client = serveur.available();
  if (!client) return WEB_RIEN;

  // On ne lit que la première ligne, par exemple : GET /ouvrir?pin=1234 HTTP/1.1
  String ligne = "";
  unsigned long debut = millis();
  while (client.connected() && millis() - debut < 1000) {
    if (client.available()) {
      char c = client.read();
      if (c == '\n') break;
      if (c != '\r') ligne += c;
    }
  }

  // Pas de code dans la demande : on affiche simplement la page
  if (ligne.indexOf("/ouvrir?pin=") < 0) {
    envoyerPage(client, "Entrez le code pour ouvrir.");
    client.stop();
    return WEB_RIEN;
  }

  // Trop d'erreurs récentes : on refuse tout, même le bon code
  if (millis() < blocageJusqua) {
    envoyerPage(client, "Trop d'essais. Patientez 30 secondes.");
    client.stop();
    return WEB_RIEN;
  }

  // Le code est bon si la ligne contient exactement « pin=1234 » suivi d'un espace
  String attendu = String("pin=") + CODE_PIN + " ";

  if (ligne.indexOf(attendu) >= 0) {
    erreursDeCode = 0;
    envoyerPage(client, "Code correct : la porte est libre 5 secondes.");
    client.stop();
    return WEB_CODE_BON;
  }

  erreursDeCode++;
  if (erreursDeCode >= 3) {
    blocageJusqua = millis() + 30000;
    erreursDeCode = 0;
  }
  envoyerPage(client, "Code incorrect.");
  client.stop();
  return WEB_CODE_FAUX;
}


// ================================================================
//  6. DÉMARRAGE ET BOUCLE PRINCIPALE
// ================================================================
void setup() {
  // Réglage des broches. Le relais en premier : la porte reste bloquée.
  pinMode(PIN_AIMANT, OUTPUT);
  bloquerPorte();
  pinMode(PIN_LED_VERTE, OUTPUT);
  pinMode(PIN_LED_ROUGE, OUTPUT);
  pinMode(PIN_BUZZER, OUTPUT);
  digitalWrite(PIN_LED_VERTE, LOW);
  digitalWrite(PIN_LED_ROUGE, LOW);
  digitalWrite(PIN_BUZZER, LOW);

  Serial.begin(115200);
  delay(1500);                    // le temps d'ouvrir le moniteur série
  Serial.println("Porte à badge RFID : démarrage");

  SPI.begin();
  rfid.PCD_Init();                // démarre le lecteur RC522

  demarrerWifi();
  bip(60);
  Serial.println("Prêt : présentez un badge.");
}

void loop() {
  // 1. Un badge est posé sur le lecteur ?
  if (badgePresente()) {
    if (badgeAutorise()) deverrouiller();
    else                 refuser();
    finLectureBadge();
  }

  // 2. Le téléphone a envoyé un code ?
  int web = lireDemandeWeb();
  if (web == WEB_CODE_BON)  deverrouiller();
  if (web == WEB_CODE_FAUX) refuser();
}

6. Tester par étapes, sans prendre de risque

Pour le Projet 01, on pouvait tout essayer sur Wokwi sans acheter une seule pièce. Ici, pas de simulation : le plus sûr est d’avancer pièce par pièce, et de ne brancher la ventouse qu’à la fin.

Le lecteur seul. Branchez le lecteur RC522 à la carte (en 3,3 V !), téléversez le code et ouvrez le moniteur série (115200 bauds). Passez un badge : son numéro doit s’afficher. C’est le moment de vérifier que le lecteur répond bien sur la Uno R4. Copiez le numéro dans la liste badges, puis téléversez à nouveau.
Le relais, sans le 12 V. Passez un badge autorisé : le relais doit cliquer, puis cliquer à nouveau 5 secondes plus tard. S’il fait l’inverse (un clic au repos, un clic à la fin), mettez LOW dans RELAIS_ACTIF.
Les voyants et le buzzer. Avec un badge autorisé : voyant vert et un bip. Avec un mauvais badge : voyant rouge et trois bips.
La ventouse, posée sur la table. Branchez l’adaptateur 12 V, la ventouse et le bouton de sortie. La plaque doit rester collée. Passez le badge : elle se décolle 5 secondes, puis reprend. Appuyez sur le bouton de sortie : elle se décolle tant que vous appuyez.
Le téléphone. Connectez-vous au réseau « Porte-Chambre », ouvrez l’adresse affichée dans le moniteur série et tapez le code PIN. Tapez ensuite trois fois un faux code : la page doit se bloquer 30 secondes.
Seulement après tout ça, la pose sur la porte (partie 7).

7. La pose sur la porte

Une règle guide toute l’installation : dehors, seulement le lecteur et ses voyants. Tout le reste se trouve dedans. Si l’aimant ou ses fils étaient côté couloir, il suffirait de les arracher ou de les couper pour entrer.

Dehors

Le lecteur dans un petit boîtier plastique, sur le mur à côté de la porte, du côté de la poignée, à hauteur de main.
Les deux voyants et le buzzer juste à côté, pour que la personne qui badge les voie et les entende. Ce ne sont que des voyants : les arracher n’ouvre rien.
Les fils passent par un petit trou dans le mur, caché derrière le lecteur.
Pas de métal derrière le lecteur : il l’empêche de lire les badges.

Dedans

La ventouse en haut du cadre, du côté de la poignée (à l’opposé des charnières), et la plaque en face, sur la porte. Laissez un tout petit jeu à la plaque pour qu’elle se colle bien à plat.
Le boîtier de commande (la carte et le relais) juste au-dessus du cadre, près de l’aimant. Prenez-le en plastique, car le Wi-Fi ne traverse pas le métal, et percez quelques petits trous d’aération.
Le bouton de sortie sur le mur, à hauteur de main, à côté du cadre.
L’adaptateur sur la prise la plus proche, avec un seul fil qui monte jusqu’au boîtier.
Une goulotte collée au mur, peinte de la couleur du mur, pour cacher et protéger les fils. Ne faites jamais passer de fils sur la porte elle-même : ils s’useraient à chaque ouverture.

Ce montage convient à une porte qui s’ouvre vers l’intérieur de la pièce, le cas le plus courant. Si la vôtre s’ouvre vers l’extérieur, l’aimant reste côté intérieur, mais il vous faudra des équerres en L et en Z, souvent vendues avec la ventouse. Petite astuce : certains aimants bon marché gardent un peu de magnétisme une fois coupés. Un bout de ruban adhésif sur la plaque règle le problème.

8. Au quotidien : ce qui se passe dans chaque situation

Avant d’installer quoi que ce soit, il est bon de savoir comment la porte réagit au jour le jour. Retenez surtout ceci : le système ne vous enferme jamais. Quand le courant part, il libère la porte.

Situation	Ce qui se passe
J’arrive avec mon badge	Bip, voyant vert, l’aimant lâche 5 secondes, je pousse la porte.
J’arrive avec un mauvais badge	Voyant rouge, 3 bips, la porte reste bloquée.
J’ai oublié mon badge	J’ouvre avec mon téléphone, ou quelqu’un à l’intérieur appuie sur le bouton de sortie. La clé n’ouvre pas l’aimant tant qu’il est alimenté.
Je sors de la chambre	J’appuie sur le bouton de sortie : l’aimant lâche, je sors. Le bouton ne passe pas par la carte, il marche même si elle plante.
Je sors sans fermer à clé	La porte se rebloque toute seule quand je la referme.
Je sors en fermant à clé	Serrure et aimant ensemble : c’est le plus sûr.
Délestage (coupure de courant)	L’aimant n’est plus alimenté : la porte est libre. Pour protéger la chambre, on ferme à clé, comme avant.
La carte plante	L’aimant reste alimenté : le badge ne répond plus. On sort par le bouton de sortie ; pour entrer depuis le couloir, on coupe le courant au disjoncteur et l’aimant lâche.

9. En cas de problème

Ça ne marche pas du premier coup ? C’est normal, ça arrive à tout le monde. Voici les pannes les plus probables, et par où commencer.

Le moniteur série n’affiche aucun badge : vérifiez les fils du lecteur (D13, D12, D11, D10, D9) et son alimentation en 3,3 V. Présentez le badge à quelques centimètres du lecteur, sans métal derrière.
Le relais fait l’inverse de ce qu’on attend (la porte est libre au repos et bloquée pendant l’ouverture) : en haut du code, mettez LOW au lieu de HIGH dans RELAIS_ACTIF.
Un badge est refusé alors qu’il est dans la liste : vérifiez que son numéro fait bien 4 octets (ce code refuse les badges de 7 octets) et que chaque octet a été recopié sans erreur depuis le moniteur série.
Le réseau « Porte-Chambre » n’apparaît pas : le mot de passe du Wi-Fi doit avoir au moins 8 caractères. En attendant, le badge marche quand même.
La page web ne s’ouvre pas : reprenez l’adresse affichée dans le moniteur série. En mode modem (CREER_MON_RESEAU = false), vérifiez le nom et le mot de passe du modem.
La ventouse ne lâche pas : repérez les bornes COM, NC et NO du relais avec un multimètre, et vérifiez que le bouton de sortie est bien branché sur son contact normalement fermé.
La ventouse ne tient pas la porte : vérifiez le 12 V, que la plaque est bien à plat, et le sens de la diode.
Le code ne compile pas : vérifiez que la carte choisie est bien « Arduino UNO R4 WiFi » et que la bibliothèque MFRC522 est installée.

10. Pour aller plus loin

Une fois le système en place, le plus dur est fait. Le relais, l’aimant et le bouton de sortie ne bougent plus : pour la suite, il suffit de changer la façon de dire « ouvre ».

L’empreinte digitale à la place du badge. Un capteur d’empreintes (AS608 ou R307) garde les empreintes dans sa mémoire et répond simplement « reconnu » ou « inconnu ». Il se branche sur le port série de la carte (broches 0 et 1), avec la bibliothèque Adafruit Fingerprint Sensor. Fini le badge perdu.
Le téléphone comme badge (NFC). Un module PN532, à la place du RC522, peut dialoguer avec certains téléphones. C’est à tester selon le modèle.
Des alertes sur le téléphone. Grâce au Wi-Fi, la carte peut vous envoyer un message à chaque ouverture et à chaque badge refusé. Si un badge est volé, vous saurez à quelle heure il a servi. Il faut pour cela la façon B, avec le modem et internet.

Un badge qui parle, un aimant qui obéit

Une carte, un lecteur, un aimant, et votre porte vous reconnaît. Le plus beau, c’est que vous savez exactement ce qui se passe à l’intérieur. Si une pièce lâche, vous savez laquelle changer. Si demain vous voulez ajouter une empreinte digitale ou une alerte sur le téléphone, vous savez où toucher au code. C’est tout l’esprit du Lab Maker : comprendre, tester, réussir.

Et si vous vous lancez, racontez-moi comment ça s’est passé en commentaire sous la vidéo. J’ai hâte de voir vos portes !

Le projet est résumé en moins de 3 minutes dans la vidéo du Lab Maker : la démo, le principe de l’aimant, le matériel, le montage, le câblage et le téléphone. Pour la voir, rendez-vous sur nos comptes TikTok, Facebook et Instagram.

Déjà au labo : Faire son incubateur maison grâce à Arduino.