Serrure solénoïde Arduino : verrou 12V avec MOSFET, clavier, RFID
Serrure solénoïde avec Arduino : principe du verrou 12V, pilotage par MOSFET ou relais, diode de roue libre, échauffement, clavier et RFID, fail-safe et ESP32.
Une serrure solénoïde est un pêne électrique qui se rétracte quand un courant traverse la bobine intérieure et qu'un ressort repousse dehors dès que le courant est coupé. Avec une serrure solénoïde et un Arduino, tu peux fabriquer un placard à code, une porte qui s'ouvre avec une carte RFID, un tiroir qui s'ouvre à l'empreinte digitale ou une boîte aux lettres que tu déverrouilles depuis ton téléphone. Le modèle le plus courant en électronique de loisir est la petite "serrure de meuble" 12 V qui consomme environ 0,5 à 1 A. C'est 25 à 50 fois ce qu'une broche d'Arduino peut fournir : la serrure ne se branche donc pas directement sur une broche mais passe par un MOSFET ou un relais.
Dans ce guide, j'explique ce qu'il y a dans une serrure solénoïde, comment calculer son courant et sa puissance, deux façons de la piloter avec un MOSFET ou un relais, la diode de roue libre indispensable pour ne pas détruire ta carte et pourquoi la bobine ne doit être alimentée que brièvement. Ensuite on écrit le code d'une serrure à clavier, d'une serrure à carte RC522 et d'une serrure ESP32 que tu ouvres depuis ton téléphone. Enfin on verra les notions de fail-safe et fail-secure, qui déterminent ce qui se passe en cas de coupure de courant. Si les MOSFET sont nouveaux pour toi, utiliser un MOSFET avec Arduino est un bon point de départ.
Qu'est-ce qu'une serrure solénoïde et comment fonctionne-t-elle ?
Le mot "solénoïde" désigne une bobine de fil enroulée autour d'un tube. Quand un courant traverse la bobine, un champ magnétique se forme à l'intérieur et attire le noyau de fer (plongeur) placé au centre. Dans la serrure, ce plongeur est lié à un pêne à face inclinée. Sans courant, un ressort maintient le pêne sorti et la porte reste verrouillée ; sous 12 V, le plongeur est aspiré, le pêne rentre et la porte s'ouvre. Grâce à sa face inclinée, le pêne est repoussé quand on referme la porte puis se remet en place tout seul : verrouiller ne demande donc aucune énergie. Pour le comportement électrique des bobines, consulte qu'est-ce qu'une bobine.
| Caractéristique | Serrure solénoïde 12 V typique | Remarque |
|---|---|---|
| Tension de service | 12 V continu | Force faible à 9 V ; à 5 V, elle ne s'ouvre généralement pas |
| Courant | 0,5 à 1 A (souvent 0,6 à 0,8 A) | Vérifie l'étiquette ou mesure la résistance de la bobine |
| Résistance de bobine | Environ 12 à 24 Ω | I = U / R ; 0,75 A pour 16 Ω |
| Puissance | 6 à 12 W | P = U × I ; 12 V × 0,75 A = 9 W |
| Durée d'alimentation | Quelques secondes (10 s max sur la plupart) | Chauffe si elle reste ouverte en continu |
| En cas de coupure | Reste verrouillée (fail-secure) | Les ventouses électromagnétiques, elles, s'ouvrent |
Si tu ne connais pas le courant de ta serrure, mets le multimètre en ohmmètre, mesure la résistance entre les deux fils de la bobine et calcule le courant avec le calculateur de loi d'Ohm. Si tu mesures 16 Ω sous 12 V, la serrure consomme 0,75 A ; choisis une alimentation d'au moins le double, soit 12 V 2 A. Au premier appel, le courant peut grimper brièvement, et si la tension d'un adaptateur faible s'effondre, la serrure ne s'ouvre pas complètement.
Piloter la serrure solénoïde avec un MOSFET ou un relais
Il existe deux méthodes courantes. Un MOSFET est silencieux, rapide, inusable et peu encombrant ; bien choisi, il ne chauffe même pas. Ce qu'il faut chercher, c'est un modèle "logic level" : sa grille doit le rendre totalement passant à 5 V, ou à 3,3 V avec un ESP32. L'IRLZ44N présente environ 0,025 Ω à 5 V ; à 0,75 A il dissipe P = R × I² ≈ 14 mW, inutile de prévoir un radiateur. Les modules IRF520 très répandus sont au contraire prévus pour une grille à 10 V et restent à moitié passants et chauds à 5 V. Un module relais est simple et isole aussi les deux circuits ; ses défauts sont le clic, l'usure des contacts et le courant consommé par sa propre bobine. Pour choisir un transistor ou un MOSFET, consulte les valeurs de l'outil transistors.
| Liaison (circuit MOSFET) | Où ? | Pourquoi ? |
|---|---|---|
| Serrure rouge (+) | + de l'adaptateur 12 V | La bobine reste toujours côté plus |
| Serrure noir (-) | Drain (D) du MOSFET | Le MOSFET commute le côté moins |
| Source (S) du MOSFET | - de l'adaptateur 12 V et GND de l'Arduino | Masse commune |
| Grille (G) du MOSFET | Arduino D10 via 220 Ω | Limite le pic de courant de charge de la broche |
| Résistance de 10 kΩ | Entre grille et GND | Évite que la serrure s'ouvre à la mise sous tension |
| Diode 1N4007 | En inverse aux bornes de la serrure ; bague vers +12 V | Absorbe la surtension inverse de la bobine |
| Condensateur de 470 µF | Entre + et - du 12 V, près de la serrure | Atténue la chute de tension à l'appel |
Alimenter l'Arduino et la serrure avec le même adaptateur 12 V est pratique : tu peux brancher le 12 V sur la prise jack de l'Uno. Mais la tension chute un instant quand la serrure tire, et le régulateur de l'Uno chauffe en abaissant 12 V à 5 V ; une solution plus robuste consiste à ramener le 12 V à 5 V avec un module LM2596 et à alimenter la carte par sa broche 5V. Dans tous les cas, la source du MOSFET, le moins de l'adaptateur et le GND de l'Arduino doivent se rejoindre en un point ; j'explique pourquoi en détail dans GND et masse commune.
Alimentation brève et échauffement : combien de temps garder la serrure ouverte ?
Dissiper 9 W dans une petite bobine, c'est comme faire tourner un petit fer à souder dans le creux de ta main. Les serrures de meuble bon marché sont généralement prévues pour un service intermittent : s'ouvrir quelques secondes ne pose aucun problème, mais maintenue ouverte pendant des minutes, la bobine devient brûlante, le vernis isolant se dégrade et la serrure s'affaiblit avec le temps. Définis donc toujours dans le logiciel une durée d'ouverture maximale ; dans les codes de cet article, elle est de 3 secondes. Si la porte doit rester ouverte longtemps, deux solutions : choisir une serrure qui retient le pêne mécaniquement, ou donner toute la puissance à l'appel puis la réduire en PWM. La bobine a besoin de bien plus de force pour attirer le pêne que pour le retenir ; après 200 ms à pleine puissance, une PWM de 30 à 40 % garde le pêne rentré sur la plupart des serrures et divise l'échauffement par plusieurs. Le principe de la PWM est expliqué dans qu'est-ce que la PWM.
Serrure à code avec clavier et solénoïde

Le premier projet utilise un clavier 4x4 pour saisir le code. Relie les broches de ligne à D9, D8, D7, D6 et celles de colonne à D5, D4, D3, D2 ; la grille du MOSFET va sur D10 et un petit buzzer actif sur A0. Installe la bibliothèque Keypad de Mark Stanley depuis le gestionnaire de bibliothèques. Tu tapes le code et valides avec #, tandis que * efface la saisie. Après trois erreurs, le clavier se bloque 30 secondes ; cette petite mesure rend pratiquement impossible de trouver le code au hasard. Le fonctionnement interne du clavier est expliqué dans l'article sur le clavier matriciel.
1// Keypad şifreli solenoid kilit / keypad-code solenoid lock
2#include <Keypad.h>
3
4const int LOCK_PIN = 10; // MOSFET gate (220 ohm üzerinden / via 220 ohm)
5const int BUZZER_PIN = A0; // aktif buzzer / active buzzer
6const unsigned long OPEN_MS = 3000; // kilit açık süresi / unlock time
7const unsigned long LOCKOUT_MS = 30000; // 3 hatadan sonra bekleme / lockout after 3 errors
8const char* PASSWORD = "2580"; // şifreyi değiştir / change the code
9
10const byte ROWS = 4, COLS = 4;
11char keys[ROWS][COLS] = {
12 {'1', '2', '3', 'A'},
13 {'4', '5', '6', 'B'},
14 {'7', '8', '9', 'C'},
15 {'*', '0', '#', 'D'}
16};
17byte rowPins[ROWS] = {9, 8, 7, 6};
18byte colPins[COLS] = {5, 4, 3, 2};
19Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);
20
21String input = "";
22int wrongCount = 0;
23bool lockedOut = false;
24unsigned long lockoutStart = 0;
25
26void beep(int ms) {
27 digitalWrite(BUZZER_PIN, HIGH);
28 delay(ms);
29 digitalWrite(BUZZER_PIN, LOW);
30}
31
32void unlock() {
33 digitalWrite(LOCK_PIN, HIGH); // bobine enerji ver, dil çekilir / energise coil, bolt retracts
34 delay(OPEN_MS); // yalnız kısa süre / short time only
35 digitalWrite(LOCK_PIN, LOW); // yay dili geri iter / spring pushes the bolt back
36}
37
38void setup() {
39 pinMode(LOCK_PIN, OUTPUT);
40 digitalWrite(LOCK_PIN, LOW); // açılışta kilitli / locked at power-up
41 pinMode(BUZZER_PIN, OUTPUT);
42}
43
44void loop() {
45 char k = keypad.getKey();
46 if (!k) return;
47
48 if (lockedOut) {
49 if (millis() - lockoutStart < LOCKOUT_MS) { beep(300); return; }
50 lockedOut = false;
51 }
52 beep(30);
53
54 if (k == '*') { input = ""; return; } // temizle / clear
55 if (k == '#') { // onayla / confirm
56 if (input == PASSWORD) {
57 wrongCount = 0;
58 unlock();
59 } else {
60 beep(600);
61 if (++wrongCount >= 3) { // kaba kuvvete karşı / against brute force
62 lockedOut = true;
63 lockoutStart = millis();
64 wrongCount = 0;
65 }
66 }
67 input = "";
68 return;
69 }
70 if (input.length() < 8) input += k; // en fazla 8 hane / max 8 digits
71}Serrure qui s'ouvre avec une carte RFID (RC522)

Dans le deuxième projet, la serrure s'ouvre quand on présente une carte RFID enregistrée. Câble le RC522 sur l'Uno ainsi : SDA → D10, SCK → D13, MOSI → D11, MISO → D12, RST → D9, 3.3V → 3.3V et GND → GND ; le SPI occupant D10 à D13, la grille du MOSFET passe cette fois sur D6. Installe la bibliothèque MFRC522, téléverse le code, présente ta carte et recopie dans la liste ALLOWED l'UID affiché dans le moniteur série. Comme les UID de cartes peuvent être clonés, cette méthode convient aux placards et tiroirs ; seule, elle ne suffit pas là où il faut une grande sécurité, comme une porte d'entrée. Pour les détails du RC522, consulte le guide RFID RC522.
1// RFID kartla solenoid kilit / RFID card solenoid lock
2#include <SPI.h>
3#include <MFRC522.h>
4
5const int SS_PIN = 10; // RC522 SDA
6const int RST_PIN = 9; // RC522 RST
7const int LOCK_PIN = 6; // MOSFET gate
8const unsigned long OPEN_MS = 3000;
9
10// Yetkili kart UID'leri, Seri Monitör'den oku / authorised UIDs, read them from the Serial Monitor
11const byte ALLOWED[][4] = {
12 {0xDE, 0xAD, 0xBE, 0xEF},
13 {0x12, 0x34, 0x56, 0x78}
14};
15const int ALLOWED_COUNT = sizeof(ALLOWED) / sizeof(ALLOWED[0]);
16
17MFRC522 rfid(SS_PIN, RST_PIN);
18
19bool isAllowed(const byte* uid, byte size) {
20 if (size != 4) return false;
21 for (int i = 0; i < ALLOWED_COUNT; i++) {
22 if (memcmp(uid, ALLOWED[i], 4) == 0) return true;
23 }
24 return false;
25}
26
27void setup() {
28 Serial.begin(9600);
29 pinMode(LOCK_PIN, OUTPUT);
30 digitalWrite(LOCK_PIN, LOW);
31 SPI.begin();
32 rfid.PCD_Init();
33}
34
35void loop() {
36 if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) return;
37
38 Serial.print("UID:");
39 for (byte i = 0; i < rfid.uid.size; i++) {
40 Serial.print(rfid.uid.uidByte[i] < 0x10 ? " 0" : " ");
41 Serial.print(rfid.uid.uidByte[i], HEX);
42 }
43 Serial.println();
44
45 if (isAllowed(rfid.uid.uidByte, rfid.uid.size)) {
46 Serial.println("Açıldı / unlocked");
47 digitalWrite(LOCK_PIN, HIGH);
48 delay(OPEN_MS);
49 digitalWrite(LOCK_PIN, LOW);
50 } else {
51 Serial.println("Yetkisiz kart / unknown card");
52 }
53 rfid.PICC_HaltA(); // kartı beklemeye al / halt the card
54}Que se passe-t-il en cas de coupure ? Fail-safe et fail-secure
La première question à se poser en choisissant une serrure électrique : la porte doit-elle rester ouverte ou verrouillée en cas de coupure ? Les serrures fail-secure restent verrouillées sans courant ; c'est le cas des solénoïdes de type serrure de meuble, le bon choix pour un coffre, un tiroir ou une boîte à colis. Les serrures fail-safe s'ouvrent au contraire quand le courant est coupé ; c'est le principe des ventouses électromagnétiques des bâtiments, car en cas d'incendie ou de panne il faut pouvoir sortir. Monter une serrure fail-secure sur une porte d'évacuation est dangereux et contraire à la réglementation dans la plupart des pays.
| Type de serrure | En cas de coupure | Usage adapté |
|---|---|---|
| Serrure solénoïde de meuble | Reste verrouillée (fail-secure) | Placards, coffres, tiroirs, boîtes |
| Ventouse électromagnétique | S'ouvre (fail-safe) | Entrées d'immeubles, issues de secours |
| Gâche électrique | L'un ou l'autre selon le modèle | En complément d'une serrure existante |
| Serrure motorisée | Reste dans sa dernière position | Serrures connectées, systèmes sur piles |
Si tu utilises une serrure fail-secure, prévois une solution de secours pour ne pas rester dehors : une clé mécanique de secours, un bouton d'ouverture d'urgence caché ou une batterie de secours capable d'alimenter la serrure et l'Arduino un moment. Une petite batterie au plomb 12 V ou un pack lithium 3S avec circuit de charge suffit par exemple pour quelques centaines d'ouvertures pendant une coupure.
Ouvrir la serrure solénoïde depuis ton téléphone avec un ESP32
L'ESP32 est le moyen le plus simple d'ouvrir la serrure en Wi-Fi. Le code ci-dessous crée un petit serveur Web ; quand tu ouvres dans le navigateur de ton téléphone l'adresse IP affichée dans le moniteur série, il demande un nom d'utilisateur et un mot de passe, puis affiche un gros bouton OUVRIR. Un appui ouvre la serrure 3 secondes et la reverrouille automatiquement grâce à millis(), pendant que le serveur continue de tourner. Différence importante : les broches de l'ESP32 délivrent 3,3 V. Un IRLZ44N risque de ne pas être totalement passant à cette tension ; utilise un MOSFET spécifié pour commuter entre 2,5 et 4,5 V, comme l'IRLB8721 ou l'AO3400, ou pilote la serrure avec un module relais qui se déclenche en 3,3 V. Pour alimenter l'ESP32 depuis le 12 V, abaisse-le à 5 V avec un LM2596 et branche-le sur la broche 5V (VIN).
1// ESP32: telefondan solenoid kilit açma / open the solenoid lock from your phone
2#include <WiFi.h>
3#include <WebServer.h>
4
5const char* WIFI_SSID = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
6const char* WIFI_PASS = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
7const char* WEB_USER = "kapi"; // sayfa kullanıcı adı / page user name
8const char* WEB_PASS = "degistir-beni"; // sayfa şifresi, değiştir / page password, change it
9const int LOCK_PIN = 26; // MOSFET gate (3,3 V ile tam açılan / fully on at 3.3 V)
10const unsigned long OPEN_MS = 3000;
11
12WebServer server(80);
13bool isOpen = false;
14unsigned long openedAt = 0;
15
16const char PAGE[] = R"html(<!DOCTYPE html><html><head>
17<meta name="viewport" content="width=device-width,initial-scale=1"><title>Kapi</title></head>
18<body style="font-family:sans-serif;text-align:center;margin-top:40px">
19<h2>Solenoid kilit / lock</h2>
20<form method="POST" action="/open"><button style="font-size:28px;padding:20px 40px">AC / OPEN</button></form>
21</body></html>)html";
22
23bool checkAuth() {
24 if (server.authenticate(WEB_USER, WEB_PASS)) return true;
25 server.requestAuthentication(); // tarayıcı şifre sorar / browser asks for a password
26 return false;
27}
28
29void handleRoot() {
30 if (!checkAuth()) return;
31 server.send(200, "text/html", PAGE);
32}
33
34void handleOpen() {
35 if (!checkAuth()) return;
36 if (!isOpen) {
37 digitalWrite(LOCK_PIN, HIGH); // kilidi aç / unlock
38 isOpen = true;
39 openedAt = millis();
40 }
41 server.sendHeader("Location", "/");
42 server.send(303); // ana sayfaya dön / back to the main page
43}
44
45void setup() {
46 pinMode(LOCK_PIN, OUTPUT);
47 digitalWrite(LOCK_PIN, LOW);
48 Serial.begin(115200);
49 WiFi.mode(WIFI_STA);
50 WiFi.begin(WIFI_SSID, WIFI_PASS);
51 while (WiFi.status() != WL_CONNECTED) delay(500);
52 Serial.println(WiFi.localIP()); // bu adresi telefonda aç / open this on your phone
53
54 server.on("/", HTTP_GET, handleRoot);
55 server.on("/open", HTTP_POST, handleOpen);
56 server.begin();
57}
58
59void loop() {
60 server.handleClient();
61 if (isOpen && millis() - openedAt >= OPEN_MS) { // süre dolunca kilitle / relock when time is up
62 digitalWrite(LOCK_PIN, LOW);
63 isOpen = false;
64 }
65}- Le serveur n'est accessible que sur le réseau de la maison ; pour ouvrir depuis l'extérieur, passe par un intermédiaire comme un bot Telegram ou MQTT plutôt que d'ouvrir un port sur ta box.
- Le mot de passe demandé par le navigateur circule presque en clair sur le réseau ; c'est acceptable à la maison, mais ton mot de passe Wi-Fi doit être solide et tu dois changer WEB_PASS.
- La commande d'ouverture est envoyée en POST : le navigateur ne peut donc pas déclencher la serrure en préchargeant la page ou en la rouvrant depuis l'historique.
- Pour aller plus loin avec la page Web et l'affichage de l'état en direct, consulte serveur Web ESP32 et WebSocket.
Erreurs fréquentes et solutions
| Symptôme | Cause | Solution |
|---|---|---|
| La serrure claque mais ne s'ouvre pas | Courant de l'adaptateur insuffisant ou tension qui chute | Prends une alimentation 12 V 2 A et un condensateur de 470 µF |
| L'Arduino redémarre à l'ouverture | Pas de diode de roue libre ou masses non communes | Ajoute la diode et relie les masses en un point |
| Le MOSFET chauffe | Pas logic level (ex. IRF520) ou résistance de grille trop grande | Utilise un IRLZ44N, ou IRLB8721/AO3400 sur ESP32 |
| La serrure s'ouvre un instant à la mise sous tension | Grille flottante | Ajoute 10 kΩ entre grille et GND |
| La serrure ne se referme jamais | MOSFET claqué (souvent faute de diode) | Remplace le MOSFET et ajoute la diode |
| La bobine chauffe beaucoup | Elle reste alimentée trop longtemps | Limite la durée d'ouverture ou baisse la puissance de maintien en PWM |
Avec un MOSFET, une diode et quelques lignes de code, une serrure solénoïde peut être l'un de tes premiers projets qui ouvre et ferme vraiment quelque chose. Dans l'application BlueGrays, tu trouveras des projets comme l'authentification RFID, une serrure à code avec clavier et LCD, un coffre-fort électronique intelligent et une serrure de porte RFID à ESP32, chacun avec schéma et code pas à pas, prêts à recevoir le circuit de pilotage du solénoïde de cet article.
Questions fréquentes
Peut-on brancher une serrure solénoïde directement sur un Arduino ?
Non. Une serrure solénoïde 12 V consomme 0,5 à 1 A, alors qu'une broche d'Arduino fournit au plus 20 à 40 mA sous 5 V. Alimente la serrure avec une source 12 V séparée via un MOSFET logic level (comme l'IRLZ44N) ou un module relais. N'oublie pas la diode de roue libre aux bornes de la bobine.
Combien d'ampères consomme une serrure solénoïde ?
Les serrures de meuble 12 V utilisées en électronique de loisir consomment en général 0,5 à 1 A, le plus souvent 0,6 à 0,8 A. Tu peux mesurer la résistance de la bobine et calculer avec I = U / R ; une bobine de 16 Ω consomme 0,75 A sous 12 V. Choisis une alimentation d'au moins le double.
Quel MOSFET utiliser pour une serrure solénoïde ?
Sur les cartes 5 V comme l'Arduino Uno, des MOSFET logic level comme l'IRLZ44N ou l'IRL540N conviennent. Sur les cartes 3,3 V comme l'ESP32 et le Pico, choisis des modèles totalement passants à basse tension, comme l'IRLB8721 ou l'AO3400. Les modules IRF520 sont déconseillés car ils demandent 10 V sur la grille.
Pourquoi faut-il une diode de roue libre ?
Quand le courant d'une bobine est coupé, le champ magnétique s'effondre et produit une surtension inverse de plusieurs centaines de volts. Ce pic détruit le MOSFET, réinitialise l'Arduino ou abîme sa broche. Une diode comme la 1N4007, branchée en inverse aux bornes de la serrure, absorbe ce pic sans danger.
Peut-on garder une serrure solénoïde ouverte en permanence ?
La plupart des serrures de meuble bon marché sont prévues pour un service intermittent et deviennent brûlantes en quelques minutes si on les alimente en continu. Limite par logiciel la durée d'ouverture à quelques secondes. Si elle doit rester ouverte plus longtemps, donne toute la puissance à l'appel puis réduis la puissance de maintien en PWM.
Une serrure solénoïde s'ouvre-t-elle en cas de coupure de courant ?
Les serrures solénoïdes de meuble sont fail-secure : elles restent verrouillées quand le courant est coupé. Les ventouses électromagnétiques sont fail-safe et s'ouvrent sans courant. On préfère les serrures fail-safe sur les issues de secours et les fail-secure sur les coffres et placards.
Projets à réaliser après cet article
Voir tous les projets
Coffre-fort électronique intelligent
Un petit coffre-fort pour tes objets précieux, qui s'ouvre avec un code. Tu tapes ton code à quatre chiffres sur le clavier ; s'il est bon, le servomoteur ouvre le verrou, la lumière verte s'allume…

Serrure à code avec clavier 4x4 et écran LCD
Une petite serrure électronique qui ne laisse entrer que ceux qui connaissent le code.

Authentification par RFID
Comme le badge d'entrée d'un immeuble : tu approches ta carte du lecteur RFID, et l'Arduino compare son numéro avec celui qu'il a en mémoire.

Lecture des valeurs RFID
Le badge de ton immeuble ou ta carte d'accès cache un numéro d'identité secret, et ce projet le lit. Approche la carte du lecteur RFID, et l'Arduino écrit son numéro sur l'écran de ton ordinateur.

Serrure de porte RFID ESP32 (RC522 + servomoteur + écran OLED + buzzer + LED)
On fabrique une serrure connectée avec un ESP32, un module RFID RC522, un servo SG90, un écran OLED SSD1306, un buzzer actif et 2 LED. L'UID de la carte lue est comparé aux cartes autorisées définies dans le code ; s'il correspond, le servo ouvre (LED verte + 2 bips courts) puis referme au bout de 5 secondes. Une carte inconnue allume la LED rouge, déclenche 3 bips rapides et affiche son UID sur l'OLED.

Lecteur de cartes RFID RC522 pour ESP32 (avec LCD)
Dans ce projet, nous allons connecter le module RFID RC522 basé sur le MFRC522 à l'ESP32 via SPI afin de lire l'UID d'une carte ou d'un badge. Cela constitue la base d'applications telles que les serrures de porte, les systèmes d'adhésion et le contrôle d'accès. Nous afficherons l'UID lu sur un écran LCD ; cette version ne le compare pas à une liste de cartes autorisées. ATTENTION : le RC522 fonctionne uniquement en 3,3 V ; 5 V grillerait le module !

Fonctionnement du clavier 3x4
L'Arduino sait tout de suite quelle touche tu appuies sur un clavier de 12 touches qui ressemble à celui d'un téléphone, et l'écrit sur l'écran de ton ordinateur.

Ampoule 220V avec bouton poussoir (Push)
Tant que tu appuies sur le bouton, une vraie ampoule de 220 volts reste allumée, et elle s'éteint dès que tu relâches.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

