Arduino-solenoïdeslot: 12V-deurslot met MOSFET, keypad en RFID
Gids voor een Arduino-solenoïdeslot: werking van een 12V-slot, aansturen met MOSFET of relais, vrijloopdiode, verwarming, keypad- en RFID-sloten, fail-safe vs fail-secure, ESP32.
Een solenoïdeslot is een elektrische grendel die zijn pen terugtrekt zodra er stroom door de spoel erin loopt, en die door een veer weer naar buiten wordt geduwd als de stroom stopt. Met een Arduino-solenoïdeslot bouw je een kastje met codebeveiliging, een deur die opent met een RFID-kaart, een lade die opent met je vingerafdruk of een brievenbus die je vanaf je telefoon ontgrendelt. Het meest gebruikte type in hobbyprojecten is het kleine 12V-"kastslot" dat ongeveer 0,5-1 A trekt. Dat is 25 tot 50 keer wat een Arduino-pin kan leveren, dus het slot wordt niet rechtstreeks vanaf een pin aangestuurd, maar via een MOSFET of een relais.
In deze gids leg ik uit wat er in een solenoïdeslot zit, hoe je de stroom en het vermogen berekent, twee manieren om het aan te sturen met een MOSFET of een relais, de vrijloopdiode die je nodig hebt om je board niet te vernielen en waarom je de spoel maar kort onder spanning mag zetten. Daarna schrijven we code voor een keypad-codeslot, een RC522-kaartslot en een ESP32-slot dat je vanaf je telefoon opent. Tot slot kijken we naar fail-safe en fail-secure, die bepalen wat er gebeurt als de stroom uitvalt. Als MOSFETs nieuw voor je zijn, is Een MOSFET gebruiken met Arduino een goed begin.
Wat is een solenoïdeslot en hoe werkt het?
Het woord "solenoïde" beschrijft een draadspoel die om een buis is gewikkeld. Als er stroom door de spoel loopt, ontstaat er in de spoel een magnetisch veld dat de ijzeren kern (plunjer) in het midden naar zich toe trekt. In een slot zit de plunjer vast aan een schuine grendel. Zonder stroom houdt een veer de grendel naar buiten en blijft de deur op slot; zet je er 12 V op, dan wordt de plunjer naar binnen getrokken, trekt de grendel terug en gaat de deur open. Dankzij de schuine kant van de grendel duwt het sluiten van de deur de grendel naar binnen, waarna hij weer op zijn plek klikt; vergrendelen kost dus helemaal geen stroom. Wil je weten hoe spoelen zich elektrisch gedragen, lees dan Wat is een spoel?.
| Eigenschap | Typisch 12V-solenoïde-kastslot | Opmerking |
|---|---|---|
| Werkspanning | 12 V DC | Zwakke trekkracht bij 9 V; bij 5 V opent het meestal niet |
| Stroom | 0,5-1 A (0,6-0,8 A is gebruikelijk) | Controleer het label of meet de spoelweerstand |
| Spoelweerstand | Ongeveer 12-24 Ω | I = V / R; 0,75 A bij 16 Ω |
| Vermogen | 6-12 W | P = V × I; 12 V × 0,75 A = 9 W |
| Bekrachtigingstijd | Een paar seconden (bij de meeste modellen maximaal 10 s) | Wordt warm als je het continu open houdt |
| Bij stroomuitval | Blijft op slot (fail-secure) | Magnetische deursloten doen het tegenovergestelde en gaan open |
Als je de stroom van je slot niet kent, zet je de multimeter op ohm, meet je de weerstand tussen de twee aansluitingen van de spoel en bereken je de stroom met de wet van Ohm-calculator. Meet je 16 Ω bij 12 V, dan trekt het slot 0,75 A; kies een voeding die minstens twee keer zoveel kan leveren, dus 12 V 2 A. De stroom kan bij de eerste trek even piekken, en als de spanning van een zwakke adapter inzakt, opent het slot niet volledig.
Het solenoïdeslot aansturen met een MOSFET of een relais
Er zijn twee gangbare methoden. Een MOSFET is stil, snel, slijt niet en neemt weinig ruimte in; goed gekozen wordt hij zelfs niet warm. Waar je op moet letten is "logic level": de gate moet volledig openen bij 5 V, of bij 3,3 V als je een ESP32 gebruikt. De IRLZ44N heeft bij 5 V ongeveer 0,025 Ω weerstand; bij 0,75 A is het vermogen dat hij dissipeert P = I² × R ≈ 14 mW, dus een koelplaat is niet nodig. De populaire IRF520-modules zijn daarentegen ontworpen voor een gate van 10 V en blijven bij 5 V half open en heet. Een relaismodule is eenvoudig en scheidt de twee schakelingen ook galvanisch; nadelen zijn de klik, contactslijtage en de stroom die de eigen spoel trekt. Om een transistor of MOSFET te kiezen, controleer je de waarden in de transistortool.
| Aansluiting (MOSFET-schakeling) | Waarheen? | Waarom? |
|---|---|---|
| Slot rood (+) | 12V-adapter + | De spoel zit altijd aan de positieve kant |
| Slot zwart (-) | MOSFET drain (D) | De MOSFET schakelt de negatieve kant |
| MOSFET source (S) | 12V-adapter - en Arduino GND | Gemeenschappelijke massa |
| MOSFET gate (G) | Arduino D10 via 220 Ω | Beperkt de laadstroompiek van de pin |
| Weerstand van 10 kΩ | Tussen gate en GND | Voorkomt dat het slot opent bij het opstarten |
| 1N4007-diode | In sperrichting over het slot; kant met streep naar +12 V | Neemt de omgekeerde spanningspiek van de spoel op |
| Condensator van 470 µF | Tussen 12 V + en -, dicht bij het slot | Vermindert de spanningsdip bij het aantrekken |
De Arduino en het slot voeden vanuit dezelfde 12V-adapter is praktisch: je kunt de Uno via de DC-jack met 12 V voeden. Maar de spanning zakt even in als het slot aantrekt en de regelaar van de Uno wordt warm van het afbouwen van 12 V naar 5 V; een robuustere optie is om de 12 V met een LM2596-module naar 5 V te verlagen en het board via de 5V-pin te voeden. In beide gevallen moeten de source van de MOSFET, de min van de adapter en de GND van de Arduino op één punt samenkomen; waarom, leg ik uitgebreid uit in GND en gemeenschappelijke massa.
Korte bekrachtiging en warmte: hoe lang kun je het slot open houden?
9 W verstoken in een kleine spoel is alsof je een klein soldeerbout in de ruimte van je handpalm laat draaien. Goedkope kastsloten zijn meestal ontworpen voor onderbroken bedrijf: een paar seconden openen is prima, maar minutenlang open gehouden wordt de spoel te heet om aan te raken, degradeert de isolatielak en verzwakt het slot na verloop van tijd. Daarom moet je in software altijd een maximale openingstijd instellen; in de code van dit artikel is dat 3 seconden. Moet de deur lang open blijven, dan zijn er twee oplossingen: kies een slot dat zijn grendel mechanisch open houdt, of geef volle kracht bij het aantrekken en verlaag die daarna met PWM. Een spoel heeft veel meer kracht nodig om de grendel binnen te trekken dan om hem vast te houden; na 200 ms op vol vermogen houdt 30-40% PWM de grendel bij de meeste sloten binnen en verlaagt de verwarming met een factor enkele keren. Hoe PWM werkt, vind je in Wat is PWM?.
Een keypad-codeslot met een solenoïde

Het eerste project gebruikt een 4x4-keypad om een code in te voeren. Sluit de rijpins van het keypad aan op D9, D8, D7, D6 en de kolompins op D5, D4, D3, D2; de MOSFET-gate gaat naar D10 en een kleine actieve buzzer naar A0. Installeer de Keypad-bibliotheek van Mark Stanley via de Library Manager. Je typt de code en bevestigt met #, terwijl * de invoer wist. Na drie foute pogingen blokkeert het keypad 30 seconden; die kleine maatregel maakt het raden van de code door te proberen praktisch onmogelijk. Hoe het keypad van binnen werkt, lees je in het artikel over het keypad.
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}Een slot dat opent met een RFID-kaart (RC522)

In het tweede project opent het slot als een geregistreerde RFID-kaart wordt gescand. Sluit de RC522 als volgt aan op de Uno: SDA → D10, SCK → D13, MOSI → D11, MISO → D12, RST → D9, 3.3V → 3.3V en GND → GND; omdat SPI D10-D13 gebruikt, gaat de MOSFET-gate nu naar D6. Installeer de MFRC522-bibliotheek, upload de code, scan je kaart en kopieer de UID die in de Serial Monitor verschijnt naar de ALLOWED-lijst. Omdat kaart-UID's te klonen zijn, past deze methode bij kastjes en laden; op zichzelf is het niet genoeg waar hoge beveiliging nodig is, zoals bij een buitendeur. Voor details over de RC522, zie de RFID RC522-gids.
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}Wat gebeurt er bij stroomuitval? Fail-safe vs fail-secure
De eerste vraag bij het kiezen van een elektrisch slot: moet de deur open of op slot blijven als de stroom uitvalt? Fail-secure-sloten blijven zonder stroom op slot; solenoïdes van het kastslot-type werken zo, en ze zijn de juiste keuze voor kluizen, laden en afleverboxen. Fail-safe-sloten gaan open als de stroom wordt onderbroken; de magnetische deursloten (elektromagneten) in gebouwen werken zo, omdat mensen bij brand of een black-out naar buiten moeten kunnen. Een fail-secure slot monteren op een deur die een vluchtroute is, is gevaarlijk en in de meeste landen in strijd met de bouwvoorschriften.
| Slottype | Bij stroomuitval | Geschikt voor |
|---|---|---|
| Solenoïde-kastslot | Blijft op slot (fail-secure) | Kasten, kluizen, laden, boxen |
| Elektromagnetisch deurslot | Gaat open (fail-safe) | Gebouwingangen, vluchtroutes |
| Elektrische sluitplaat | Beide, afhankelijk van het model | Toegevoegd aan een bestaand deurslot |
| Gemotoriseerd slot | Blijft in de laatste stand | Slimme deursloten, batterijsystemen |
Gebruik je een fail-secure slot, bedenk dan een reserve zodat je jezelf niet buitensluit: een mechanische reservesleutel, een verborgen noodontgrendelknop of een batterijback-up die het slot en de Arduino een tijdje draaiende kan houden. Een kleine 12V-loodaccu of een 3S-lithiumpakket met laadschakeling is bijvoorbeeld genoeg voor een paar honderd openingen tijdens een storing.
Het solenoïdeslot vanaf je telefoon openen met een ESP32
De ESP32 is de eenvoudigste manier om het slot via Wi-Fi te openen. De onderstaande code zet een kleine webserver op; als je het IP-adres uit de Serial Monitor in de browser van je telefoon opent, vraagt hij om een gebruikersnaam en wachtwoord en toont dan een grote OPEN-knop. Als je erop drukt, wordt het slot 3 seconden ontgrendeld en met millis() automatisch weer vergrendeld, terwijl de server blijft draaien. Een belangrijk verschil: de pins van de ESP32 leveren 3,3 V. Een IRLZ44N gaat bij die spanning mogelijk niet volledig open; gebruik een MOSFET die specificeerd is om te schakelen bij 2,5-4,5 V, zoals de IRLB8721 of AO3400, of stuur het slot aan met een relaismodule die bij 3,3 V schakelt. Om de ESP32 vanuit 12 V te voeden, verlaag je de spanning met een LM2596 naar 5 V en voed je de 5V-pin (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}- De server is alleen bereikbaar op je thuisnetwerk; om hem van buitenaf te openen gebruik je een tussenschakel zoals een Telegram-bot of MQTT in plaats van een poort op je router open te zetten.
- Het wachtwoord dat de browser vraagt, reist bijna als leesbare tekst over het netwerk; thuis is dat acceptabel, maar je wifiwachtwoord moet sterk zijn en je moet WEB_PASS veranderen.
- Het openverzoek wordt als POST verstuurd, zodat een browser die de pagina vooraf laadt of opnieuw opent uit de geschiedenis het slot niet vanzelf kan activeren.
- Meer over de webpagina en het tonen van live status vind je in ESP32-webserver en WebSocket.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Oorzaak | Oplossing |
|---|---|---|
| Het slot klikt maar gaat niet open | Onvoldoende stroom van de adapter of de spanning zakt in | Gebruik een 12V 2A-voeding en een condensator van 470 µF |
| De Arduino reset als het slot opent | Geen vrijloopdiode of massa's niet gedeeld | Plaats de diode en verbind de massa's op één punt |
| De MOSFET wordt heet | Geen logic level (bijv. IRF520) of gateweerstand te groot | Gebruik een IRLZ44N, of IRLB8721/AO3400 op een ESP32 |
| Het slot opent even bij het opstarten | De gate zweeft | Voeg 10 kΩ toe tussen gate en GND |
| Het slot sluit nooit, altijd open | MOSFET kortgesloten (vaak door gebruik zonder diode) | Vervang de MOSFET en voeg de diode toe |
| De spoel wordt erg heet | Hij blijft te lang onder spanning | Beperk de openingstijd of verlaag het houdvermogen met PWM |
Met een MOSFET, een diode en een paar regels code kan een solenoïdeslot een van je eerste projecten zijn dat in de echte wereld fysiek iets opent en sluit. In de BlueGrays-app vind je projecten zoals RFID-authenticatie, een keypad-en-LCD-codeslot, een slimme elektronische kluis en een ESP32-RFID-deurslot, elk met schakelschema's en code stap voor stap, klaar voor de solenoïdedriverschakeling uit dit artikel.
Veelgestelde vragen
Kan een solenoïdeslot rechtstreeks op een Arduino worden aangesloten?
Nee. Een 12V-solenoïdeslot trekt 0,5-1 A, terwijl een Arduino-pin bij 5 V maximaal 20-40 mA levert. Voed het slot vanuit een aparte 12V-voeding via een logic-level MOSFET (zoals een IRLZ44N) of een relaismodule. Vergeet de vrijloopdiode over de spoel niet.
Hoeveel ampère trekt een solenoïdeslot?
De 12V-sloten van het kastslot-type die in hobbyprojecten worden gebruikt, trekken meestal 0,5-1 A, vaak 0,6-0,8 A. Je kunt de spoelweerstand meten en berekenen met I = V / R; een spoel van 16 Ω trekt 0,75 A bij 12 V. Kies een voeding die minstens twee keer zoveel kan leveren.
Welke MOSFET moet ik voor een solenoïdeslot gebruiken?
Op 5V-boards zoals de Arduino Uno werken logic-level MOSFETs zoals de IRLZ44N of IRL540N goed. Kies op 3,3V-boards zoals de ESP32 en Pico modellen die bij lage spanning volledig openen, zoals de IRLB8721 of AO3400. IRF520-modules worden niet aanbevolen omdat ze een gate van 10 V nodig hebben.
Waarom is een vrijloopdiode nodig?
Als de stroom in een spoel wordt onderbroken, klapt het magnetische veld in en ontstaat er een omgekeerde spanningspiek van honderden volts. Die piek beschadigt de MOSFET, reset de Arduino of beschadigt de pin. Een diode zoals een 1N4007, in sperrichting over het slot aangesloten, neemt de piek veilig op.
Kan een solenoïdeslot continu open worden gehouden?
De meeste goedkope kastsloten zijn ontworpen voor onderbroken bedrijf en worden binnen enkele minuten erg heet als ze continu onder spanning staan. Beperk de openingstijd in software tot een paar seconden. Moet hij langer open blijven, geef dan volle kracht bij het aantrekken en verlaag het houdvermogen daarna met PWM.
Gaat een solenoïdeslot open als de stroom uitvalt?
Solenoïdesloten van het kastslot-type zijn fail-secure, wat betekent dat ze op slot blijven als de stroom wordt onderbroken. Elektromagnetische deursloten zijn fail-safe en gaan open bij stroomverlies. Fail-safe sloten verdienen de voorkeur op deuren in vluchtroutes, fail-secure sloten op kluizen en kasten.
Projecten om hierna te bouwen
Alle projecten bekijken
Slimme elektronische kluis
Een kleine kluis voor je waardevolle spullen die opent met een code. Je tikt je viercijferige code in op het toetsenbord; klopt hij, dan opent de servomotor het slot, gaat het groene lampje aan en…

Codeslot met 4x4-keypad en LCD
Een klein elektronisch deurslot dat iedereen buiten houdt die de code niet kent.

RFID-authenticatie
Net als de kaartlezer bij een appartementsdeur: je houdt je kaart bij de RFID-lezer en de Arduino vergelijkt het nummer met het opgeslagen nummer.

RFID-waarde uitlezen
Je sleutelhanger of toegangskaart verbergt een geheim ID-nummer en dit project leest het uit. Houd de kaart bij de RFID-lezer en de Arduino schrijft het kaartnummer naar je computerscherm.

ESP32 RFID-deurslot (RC522 + servo + OLED + buzzer + LED)
We bouwen een slim deurslot met een ESP32, een RC522 RFID-module, een SG90-servo, een SSD1306 OLED-display, een actieve buzzer en 2 leds. Bij het scannen van een kaart wordt de UID vergeleken met de geautoriseerde kaarten in de code; bij een match ontgrendelt de servo (groene led + 2 korte piepjes) en vergrendelt na 5 seconden weer. Een onbekende kaart laat de rode led branden, geeft 3 snelle piepjes en toont de UID op de OLED.

ESP32 RFID-RC522-kaartlezer (met LCD)
In dit project sluit je de RC522-RFID-module op basis van de MFRC522 via SPI aan op de ESP32 en lees je de UID van een kaart of tag uit. Dit vormt de basis voor toepassingen zoals deursloten, ledensystemen en toegangscontrole. De uitgelezen UID tonen we op een LCD; deze versie vergelijkt hem niet met een lijst van geautoriseerde kaarten. LET OP: de RC522 werkt alleen op 3,3 V; geef je hem 5 V, dan brandt de module door!

3x4-keypad gebruiken
De Arduino weet direct welke toets je indrukt op een keypad met 12 toetsen dat op het toetsenbord van een telefoon lijkt, en schrijft die op het scherm van je computer.

230V-lamp laten branden met een drukknop
Zolang je de knop vasthoudt, brandt een echte lamp op netspanning, en zodra je loslaat gaat hij uit.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

