Bauteile · 8 Min. Lesezeit

Arduino Magnetschloss: 12V-Solenoid mit MOSFET, Keypad und RFID

Arduino Solenoid-Schloss: Funktionsweise des 12-V-Schlosses, Ansteuerung per MOSFET oder Relais, Freilaufdiode, Erwärmung, Keypad, RFID, Fail-Safe und ESP32.

Ein Magnetschloss (Solenoid-Schloss) ist ein elektrischer Riegel: Fließt Strom durch die Spule im Inneren, zieht er die Falle zurück, und wird der Strom abgeschaltet, drückt eine Feder sie wieder hinaus. Mit einem Arduino und einem Solenoid-Schloss baust du einen Schrank mit Zahlencode, eine Tür, die sich per RFID-Karte öffnet, eine Schublade mit Fingerabdruck oder einen Briefkasten, den du per Handy aufschließt. Am verbreitetsten ist in Hobbyprojekten das kleine 12-V-"Schrankschloss", das etwa 0,5-1 A zieht. Das ist das 25- bis 50-Fache dessen, was ein Arduino-Pin liefern kann; deshalb steuerst du das Schloss nicht direkt am Pin an, sondern über einen MOSFET oder ein Relais.

In dieser Anleitung erkläre ich den Aufbau eines Magnetschlosses, die Berechnung von Strom und Leistung, zwei Ansteuerungen per MOSFET oder Relais, die Freilaufdiode, ohne die dein Board Schaden nimmt, und warum die Spule nur kurz bestromt werden darf. Danach schreiben wir Code für ein Codeschloss mit Keypad, ein Kartenschloss mit RC522 und ein ESP32-Schloss, das du per Handy öffnest. Zum Schluss geht es um Fail-Safe und Fail-Secure, also darum, was bei Stromausfall passiert. Sind MOSFETs neu für dich, ist MOSFET mit Arduino nutzen ein guter Einstieg.

Was ist ein Magnetschloss und wie funktioniert es?

Das Wort "Solenoid" bezeichnet eine Drahtspule, die um ein Rohr gewickelt ist. Fließt Strom durch die Spule, entsteht darin ein Magnetfeld, das den Eisenkern (Anker) in der Mitte zu sich zieht. Im Schloss ist dieser Anker mit einer schrägen Falle verbunden. Ohne Strom hält eine Feder die Falle draußen, die Tür bleibt verriegelt; legst du 12 V an, wird der Anker hineingezogen, die Falle zieht sich zurück und die Tür geht auf. Dank der schrägen Seite wird die Falle beim Zumachen der Tür hineingedrückt und rastet wieder ein, Abschließen braucht also keine Energie. Wie sich Spulen elektrisch verhalten, steht im Artikel Was ist eine Spule?.

EigenschaftTypisches 12-V-SchrankschlossHinweis
Betriebsspannung12 V DCBei 9 V schwach, bei 5 V öffnet es meist gar nicht
Strom0,5-1 A (oft 0,6-0,8 A)Typenschild prüfen oder Spulenwiderstand messen
SpulenwiderstandEtwa 12-24 ΩI = U / R; bei 16 Ω 0,75 A
Leistung6-12 WP = U × I; 12 V × 0,75 A = 9 W
EinschaltdauerWenige Sekunden (bei den meisten Modellen max. 10 s)Wird bei Dauerbetrieb heiß
Bei StromausfallBleibt verriegelt (Fail-Secure)Haftmagnete an Türen öffnen dagegen

Kennst du den Strom deines Schlosses nicht, stellst du das Multimeter auf Ohm, misst den Widerstand zwischen den beiden Spulenanschlüssen und berechnest den Strom mit dem Ohmsches-Gesetz-Rechner. Misst du 16 Ω bei 12 V, zieht das Schloss 0,75 A; wähle ein Netzteil mit mindestens dem Doppelten, also 12 V 2 A. Beim ersten Anziehen kann der Strom kurz noch höher sein, und bricht die Spannung eines schwachen Netzteils ein, öffnet das Schloss nicht ganz.

Das Magnetschloss per MOSFET oder Relais ansteuern

Es gibt zwei gängige Methoden. Ein MOSFET ist lautlos, schnell, verschleißfrei und klein; richtig gewählt wird er nicht einmal warm. Entscheidend ist "Logic Level": Das Gate muss bei 5 V, beim ESP32 bei 3,3 V voll durchschalten. Der IRLZ44N hat bei 5 V etwa 0,025 Ω; bei 0,75 A verheizt er P = I² × R ≈ 14 mW, ein Kühlkörper ist unnötig. Die beliebten IRF520-Module sind dagegen für 10 V Gatespannung gedacht und bleiben bei 5 V halb offen und werden heiß. Ein Relaismodul ist einfach und trennt zugleich beide Stromkreise; Nachteile sind das Klicken, der Kontaktverschleiß und der Strom der eigenen Relaisspule. Zur Auswahl von Transistor oder MOSFET hilft dir das Transistor-Tool.

Anschluss (MOSFET-Schaltung)Wohin?Warum?
Schloss rot (+)12-V-Netzteil +Die Spule hängt immer am Plus
Schloss schwarz (-)MOSFET Drain (D)Der MOSFET schaltet die Minusseite
MOSFET Source (S)12-V-Netzteil - und Arduino-GNDGemeinsame Masse
MOSFET Gate (G)Arduino D10 über 220 ΩBegrenzt den Ladestromstoß am Pin
10-kΩ-WiderstandZwischen Gate und GNDSchloss öffnet nicht von selbst beim Einschalten
Diode 1N4007In Sperrrichtung parallel zum Schloss; Ring an +12 VFängt die Gegenspannung der Spule ab
470-µF-KondensatorZwischen 12 V + und -, nah am SchlossMildert den Spannungseinbruch beim Anziehen
Verzichte nie auf die Freilaufdiode. Wird der Strom in einer Spule plötzlich unterbrochen, bricht das Magnetfeld zusammen, und die Spule erzeugt an ihren Anschlüssen eine Gegenspannungsspitze von Hunderten Volt, um den Strom weiterfließen zu lassen. Ohne Diode schlägt diese Spitze den MOSFET durch, setzt den Arduino zurück oder zerstört seinen Pin. Schließe die Diode parallel zum Schloss an, mit dem silbernen Ring (Kathode) auf der +12-V-Seite; im Normalbetrieb leitet sie nicht und führt nur beim Abschalten den Impuls zurück in die Spule, wo er abklingt. Beim Schalten über ein Relais brauchst du dieselbe Diode, sonst brennen die Relaiskontakte bei jedem Öffnen mit einem Funken ab. Details unter Was ist eine Diode?.

Arduino und Schloss am selben 12-V-Netzteil zu betreiben ist praktisch: Den Uno kannst du über die DC-Buchse mit 12 V versorgen. Beim Anziehen des Schlosses bricht die Spannung aber kurz ein, und der Regler des Uno wird beim Absenken von 12 V auf 5 V warm; robuster ist es, die 12 V mit einem LM2596-Modul auf 5 V zu bringen und das Board über den 5V-Pin zu speisen. In jedem Fall müssen Source des MOSFET, Minus des Netzteils und GND des Arduino an einem Punkt zusammenkommen; warum, erkläre ich ausführlich in GND und gemeinsame Masse.

Kurze Einschaltdauer und Wärme: Wie lange darf das Schloss offen bleiben?

9 W in einer kleinen Spule zu verheizen ist, als würdest du auf Handflächengröße einen kleinen Lötkolben betreiben. Günstige Schrankschlösser sind meist für Kurzzeitbetrieb ausgelegt: Ein paar Sekunden öffnen ist kein Problem, minutenlang offen gehalten wird die Spule aber zu heiß zum Anfassen, der Isolierlack altert und das Schloss wird mit der Zeit schwächer. Lege deshalb in der Software immer eine maximale Öffnungsdauer fest; in den Codes dieses Artikels sind es 3 Sekunden. Muss die Tür länger offen bleiben, gibt es zwei Lösungen: ein Schloss, das die Falle mechanisch offen hält, oder volle Leistung beim Anziehen und danach Reduzieren per PWM. Zum Anziehen braucht die Spule viel mehr Kraft als zum Halten; nach 200 ms mit voller Leistung halten 30-40 % PWM die Falle bei den meisten Schlössern drinnen und senken die Erwärmung um ein Mehrfaches. Wie PWM funktioniert, steht unter Was ist PWM?.

Codeschloss mit Keypad und Magnetschloss

4x4-Folientastatur
4x4-Folientastatur: liest 16 Tasten über je 4 Zeilen- und Spaltenpins; die Keypad-Bibliothek übernimmt das Abtasten.

Im ersten Projekt gibst du den Code über ein 4x4-Keypad ein. Verbinde die Zeilenpins mit D9, D8, D7, D6 und die Spaltenpins mit D5, D4, D3, D2; das Gate des MOSFET kommt an D10, ein kleiner aktiver Summer an A0. Installiere über den Bibliotheksverwalter die Bibliothek Keypad von Mark Stanley. Du tippst den Code ein und bestätigst mit #, * löscht die Eingabe. Nach drei Fehlversuchen sperrt das Keypad für 30 Sekunden; diese kleine Maßnahme macht das Erraten durch Probieren praktisch unmöglich. Wie das Keypad innen funktioniert, steht im Artikel zum Keypad.

C++ (Arduino IDE)
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}

Schloss mit RFID-Karte (RC522)

RC522 RFID-Lesemodul
RC522: liest 13,56-MHz-MIFARE-Karten und Anhänger aus wenigen Zentimetern; Anschluss per SPI, Versorgung mit 3,3 V.

Im zweiten Projekt öffnet das Schloss, wenn eine registrierte RFID-Karte gelesen wird. Verdrahte den RC522 am Uno so: SDA → D10, SCK → D13, MOSI → D11, MISO → D12, RST → D9, 3.3V → 3.3V und GND → GND; weil SPI D10-D13 belegt, kommt das MOSFET-Gate diesmal an D6. Installiere die Bibliothek MFRC522, lade den Code hoch, halte deine Karte vor den Leser und trage die im seriellen Monitor angezeigte UID in die Liste ALLOWED ein. Da sich Karten-UIDs kopieren lassen, eignet sich das für Schränke und Schubladen; für hohe Sicherheit wie an einer Haustür reicht es allein nicht. Mehr zum RC522 steht im RFID-RC522-Ratgeber.

C++ (Arduino IDE)
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}
Nach demselben Prinzip baust du ein Fingerabdruckschloss: Ruf einfach die Öffnen-Funktion auf, wenn der Fingerabdrucksensor AS608 einen passenden Finger erkennt. Kombinierst du Keypad, Karte und Fingerabdruck zu einer Zwei-Faktor-Prüfung (erst Karte, dann Code), steigt die Sicherheit deutlich.

Was passiert bei Stromausfall? Fail-Safe und Fail-Secure

Die erste Frage bei der Wahl eines elektrischen Schlosses lautet: Soll die Tür bei Stromausfall offen oder verriegelt sein? Fail-Secure-Schlösser bleiben ohne Strom verriegelt; so arbeiten die Solenoide im Schrankschloss-Stil, und sie sind die richtige Wahl für Tresore, Schubladen und Paketboxen. Fail-Safe-Schlösser öffnen dagegen bei Stromausfall; so funktionieren die Haftmagnete (Elektromagnete) an Gebäudetüren, denn bei Brand oder Stromausfall müssen Menschen hinauskommen. Ein Fail-Secure-Schloss an einer Fluchttür ist gefährlich und verstößt fast überall gegen Bauvorschriften.

SchlosstypBei StromausfallGeeignet für
Solenoid-SchrankschlossBleibt verriegelt (Fail-Secure)Schränke, Tresore, Schubladen, Boxen
Elektromagnetisches Türschloss (Haftmagnet)Öffnet (Fail-Safe)Gebäudeeingänge, Fluchtwege
Elektrischer TüröffnerJe nach Modell beidesErgänzung zu einem vorhandenen Türschloss
MotorschlossBleibt in der letzten StellungSmarte Türschlösser, batteriebetriebene Systeme

Nutzt du ein Fail-Secure-Schloss, plane eine Rückfallebene, damit du dich nicht aussperrst: einen mechanischen Ersatzschlüssel, einen versteckten Notöffner oder eine Akkupufferung, die Schloss und Arduino eine Weile versorgt. Ein kleiner 12-V-Bleiakku oder ein 3S-Lithium-Akkupack mit Ladeschaltung reicht beispielsweise für einige hundert Öffnungen während eines Ausfalls.

Das Magnetschloss mit dem ESP32 per Handy öffnen

Mit dem ESP32 öffnest du das Schloss am einfachsten per WLAN. Der folgende Code startet einen kleinen Webserver; rufst du im Handybrowser die im seriellen Monitor angezeigte IP-Adresse auf, fragt er nach Benutzername und Passwort und zeigt dann einen großen ÖFFNEN-Knopf. Ein Druck darauf öffnet das Schloss für 3 Sekunden und verriegelt es per millis() automatisch wieder, während der Server weiterläuft. Ein wichtiger Unterschied: Die Pins des ESP32 liefern 3,3 V. Ein IRLZ44N schaltet dabei womöglich nicht voll durch; nimm einen MOSFET, der für 2,5-4,5 V spezifiziert ist, etwa IRLB8721 oder AO3400, oder steuere das Schloss über ein Relaismodul, das mit 3,3 V auslöst. Um den ESP32 aus 12 V zu versorgen, setzt du sie mit einem LM2596 auf 5 V herab und speist den 5V-(VIN-)Pin.

C++ (Arduino IDE)
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}
  • Der Server ist nur im Heimnetz erreichbar; willst du von unterwegs öffnen, nutze statt einer Portfreigabe am Router einen Vermittler wie einen Telegram-Bot oder MQTT.
  • Das vom Browser abgefragte Passwort geht fast im Klartext durchs Netz; zu Hause ist das vertretbar, aber dein WLAN-Passwort muss stark sein, und WEB_PASS musst du unbedingt ändern.
  • Der Öffnen-Befehl wird per POST gesendet; so kann der Browser das Schloss nicht durch Vorladen der Seite oder Öffnen aus dem Verlauf auslösen.
  • Mehr zur Webseite und zur Live-Statusanzeige findest du unter ESP32-Webserver und WebSocket.

Häufige Fehler und Lösungen

SymptomUrsacheLösung
Schloss klickt, öffnet aber nichtNetzteil zu schwach oder Spannung bricht ein12-V-2-A-Netzteil und 470-µF-Kondensator verwenden
Arduino startet beim Öffnen neuKeine Freilaufdiode oder keine gemeinsame MasseDiode einsetzen, Massen an einem Punkt verbinden
MOSFET wird heißKein Logic-Level-Typ (z. B. IRF520) oder Gatewiderstand zu großIRLZ44N, am ESP32 IRLB8721 oder AO3400
Schloss öffnet kurz beim EinschaltenGate hängt in der Luft10 kΩ zwischen Gate und GND
Schloss schließt nie, bleibt offenMOSFET durchlegiert (oft durch Betrieb ohne Diode)MOSFET tauschen und Diode ergänzen
Spule wird sehr heißBleibt zu lange bestromtÖffnungsdauer begrenzen oder Haltestrom per PWM senken
Beim ersten Test lässt du den Code beiseite und hältst die beiden Anschlüsse des Schlosses eine Sekunde lang direkt an das 12-V-Netzteil. Zieht sich die Falle zurück, sind Schloss und Netzteil in Ordnung, und der Fehler steckt in der Ansteuerung. Wenn nicht, prüfe zuerst mit dem Multimeter, ob das Netzteil wirklich 12 V und genug Strom liefert.

Mit einem MOSFET, einer Diode und ein paar Zeilen Code kann ein Magnetschloss eines deiner ersten Projekte sein, das in der echten Welt etwas öffnet und schließt. In der BlueGrays-App findest du Projekte wie RFID-Authentifizierung, ein Codeschloss mit Keypad und LCD, einen smarten elektronischen Tresor und ein ESP32-RFID-Türschloss, jeweils mit Schaltplan und Code Schritt für Schritt, zu denen du die Solenoid-Ansteuerung aus diesem Artikel hinzufügen kannst.

Häufige Fragen

Kann man ein Magnetschloss direkt an den Arduino anschließen?

Nein. Ein 12-V-Magnetschloss zieht 0,5-1 A, ein Arduino-Pin liefert höchstens 20-40 mA bei 5 V. Versorge das Schloss aus einem eigenen 12-V-Netzteil über einen Logic-Level-MOSFET (etwa IRLZ44N) oder ein Relaismodul. Vergiss die Freilaufdiode an der Spule nicht.

Wie viel Strom zieht ein Magnetschloss?

Die in Hobbyprojekten üblichen 12-V-Schrankschlösser ziehen meist 0,5-1 A, oft 0,6-0,8 A. Du kannst den Spulenwiderstand messen und mit I = U / R rechnen; eine 16-Ω-Spule zieht bei 12 V 0,75 A. Wähle ein Netzteil mit mindestens dem doppelten Wert.

Welcher MOSFET eignet sich für ein Magnetschloss?

An 5-V-Boards wie dem Arduino Uno passen Logic-Level-MOSFETs wie IRLZ44N oder IRL540N. An 3,3-V-Boards wie ESP32 und Pico wählst du Typen, die schon bei niedriger Spannung voll durchschalten, etwa IRLB8721 oder AO3400. IRF520-Module sind nicht zu empfehlen, weil sie 10 V am Gate brauchen.

Warum braucht man eine Freilaufdiode?

Wird der Strom in einer Spule unterbrochen, bricht das Magnetfeld zusammen und erzeugt eine Gegenspannungsspitze von Hunderten Volt. Diese Spitze zerstört den MOSFET, setzt den Arduino zurück oder schädigt seinen Pin. Eine Diode wie die 1N4007 in Sperrrichtung parallel zum Schloss baut die Spitze gefahrlos ab.

Darf ein Magnetschloss dauerhaft offen gehalten werden?

Die meisten günstigen Schrankschlösser sind für Kurzzeitbetrieb gebaut und werden bei Dauerbestromung in wenigen Minuten sehr heiß. Begrenze die Öffnungsdauer per Software auf wenige Sekunden. Muss es länger offen bleiben, gib beim Anziehen volle Leistung und senke dann den Haltestrom per PWM.

Öffnet ein Magnetschloss bei Stromausfall?

Solenoid-Schrankschlösser sind Fail-Secure, bleiben bei Stromausfall also verriegelt. Elektromagnetische Türschlösser (Haftmagnete) sind Fail-Safe und öffnen ohne Strom. An Fluchttüren nimmt man Fail-Safe-, an Tresoren und Schränken Fail-Secure-Schlösser.

Alle Projekte ansehen
Intelligenter elektronischer Safe
AR-92Fortgeschritten
Premium

Intelligenter elektronischer Safe

Ein kleiner Tresor für deine Wertsachen, der sich mit einem Code öffnet. Du tippst deinen vierstelligen Code auf dem Tastenfeld ein; stimmt er, öffnet der Servomotor das Schloss, das grüne Licht geht…

4.7(42)
63
Passwortschloss mit 4x4-Tastenfeld und LCD
AR-64Fortgeschritten
Premium

Passwortschloss mit 4x4-Tastenfeld und LCD

Ein kleines elektronisches Türschloss, das niemanden ohne den richtigen Code hereinlässt.

4.8(59)
75
RFID-Authentifizierung
AR-54Mittel
Premium

RFID-Authentifizierung

Wie der Kartenzugang an der Haustür: Du hältst deine Karte an den RFID-Leser, und der Arduino vergleicht ihre Nummer mit der gespeicherten.

4.8(65)
84
RFID-Werte lesen
AR-53Anfänger
Premium

RFID-Werte lesen

In deinem Schlüsselanhänger für die Haustür oder deiner Zugangskarte steckt eine geheime Kennnummer, und dieses Projekt liest sie aus.

4.7(47)
61
ESP32-RFID-Türschloss (RC522 + Servo + OLED + Summer + LED)
ES-35Fortgeschritten
Premium

ESP32-RFID-Türschloss (RC522 + Servo + OLED + Summer + LED)

Wir bauen ein smartes Türschloss mit ESP32, RFID-Modul RC522, Servo SG90, SSD1306-OLED, aktivem Summer und 2 LEDs. Die UID einer gescannten Karte wird mit den im Code hinterlegten Karten verglichen; passt sie, öffnet der Servo das Schloss (grüne LED + 2 kurze Pieptöne) und verriegelt nach 5 Sekunden wieder. Bei einer fremden Karte leuchtet die rote LED, es piept 3-mal schnell und das OLED zeigt die UID.

4.8(9)
16
ESP32 RFID-Kartenleser RC522 (mit LCD)
ES-21Mittel

ESP32 RFID-Kartenleser RC522 (mit LCD)

In diesem Projekt schließen wir das MFRC522-basierte RC522-RFID-Modul über SPI an den ESP32 an und lesen die UID der Karte bzw. des Tags aus. Dies bildet die Grundlage für Anwendungen wie Türschlösser, Mitgliedersysteme und Zugangskontrollen. Wir zeigen die gelesene UID auf einem LCD-Display an; diese Version gleicht sie nicht mit einer Liste autorisierter Karten ab. ACHTUNG: Das RC522 arbeitet nur mit 3,3 V; bei 5 V brennt das Modul durch!

4.8(21)
42
3x4-Tastenfeld verwenden
AR-61Anfänger

3x4-Tastenfeld verwenden

Der Arduino erkennt sofort, welche Taste du auf einem 12-Tasten-Feld drückst, das wie eine Telefontastatur aussieht, und schreibt sie auf deinen Computerbildschirm.

4.5(24)
32
220V Glühbirne mit Druckknopf (Push)
AR-19Fortgeschritten
Premium

220V Glühbirne mit Druckknopf (Push)

Solange du den Knopf gedrückt hältst, leuchtet eine echte 220-Volt-Glühbirne, und sobald du loslässt, geht sie aus.

4.4(30)
38