{"id":52340,"date":"2026-11-01T10:50:59","date_gmt":"2026-11-01T10:50:59","guid":{"rendered":"http:\/\/siratek.net\/index.php\/tutorials\/rfid-door-lock\/"},"modified":"2026-11-01T10:50:59","modified_gmt":"2026-11-01T10:50:59","slug":"rfid-door-lock","status":"publish","type":"siratek_tutorial","link":"https:\/\/siratek.net\/index.php\/tutorials\/rfid-door-lock\/","title":{"rendered":"Project, an RFID Door Lock"},"content":{"rendered":"

<\/p>\n

What you will build<\/h2>\n

A cabinet that opens when you present a card. A reader on the outside, a solenoid latch on the inside, a release button, and a list of accepted cards that survives being unplugged \u2014 with a master card that adds and removes cards without a computer.<\/p>\n

Read this first: what this is for<\/h2>\n

Two limits, both from the component pages, and both of which decide where this project may be fitted.<\/p>\n

A card\u2019s UID is not a password.<\/strong> Reading RFID Cards with an RC522<\/em> puts it plainly: a UID can be read by anybody with a reader, blank cards that let you write any UID you like are cheap, and MIFARE Classic\u2019s own encryption has been thoroughly broken in published research. Anyone who can stand near your card for a second can make one that opens this.<\/p>\n

The lock is fail-secure, and it is a small latch.<\/strong> With no power the bolt stays out, so a power cut leaves it shut. A Mini Electronic Lock<\/em> says what follows from that: it suits a cabinet, a drawer, a store room or a workshop cupboard, and it must not<\/strong> go on a door that a person might need to get out through, or anything on a fire escape route. The latch itself is a spring bolt in thin metal held by four screws \u2014 it resists a casual pull and not much more.<\/p>\n

So: a convenient cabinet that opens to a card.<\/strong> That is a genuinely useful thing and it is what this project is. It is not an access control system, and anyone you build one for should be told the same.<\/p>\n

Before you begin<\/h2>\n

Parts<\/h3>\n\n\n\n\n\n\n\n\n\n\n\n\n
Part<\/th>\nSiratek product<\/th>\nIts own tutorial<\/th>\n<\/tr>\n<\/thead>\n
Arduino Uno<\/td>\n2219<\/td>\nGetting Started with Arduino Uno<\/em><\/td>\n<\/tr>\n
RC522 reader with card and fob<\/td>\n2609<\/td>\nReading RFID Cards with an RC522<\/em><\/td>\n<\/tr>\n
Mini electronic lock<\/td>\n2795<\/td>\nA Mini Electronic Lock<\/em><\/td>\n<\/tr>\n
Relay module<\/td>\n3308<\/td>\nSwitching Bigger Loads with a Relay<\/em><\/td>\n<\/tr>\n
Green and red LEDs with 220 ohm resistors<\/td>\n2234<\/td>\nYour First Circuit, an LED and a Resistor<\/em><\/td>\n<\/tr>\n
Active buzzer<\/td>\n2520<\/td>\nActive Buzzer, a Beep Without Code<\/em><\/td>\n<\/tr>\n
Push button<\/td>\n2353<\/td>\nRead a Push Button<\/em><\/td>\n<\/tr>\n
Breadboard and jumper wires<\/td>\n<\/td>\nUsing a Breadboard<\/em><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Also needed: a DC supply for the lock<\/strong>, a 1N4007 diode, and a multimeter.<\/p>\n

Settle the lock\u2019s supply before anything else<\/h3>\n

The Siratek lock has no voltage printed on it anywhere<\/strong>. These are commonly 12 V, and 6 V versions exist, and guessing is how you destroy one.<\/p>\n

Measure the coil resistance across its two wires, then current = voltage \/ resistance<\/code>. A coil reading 20 ohms draws 0.6 A at 12 V; one reading 7 ohms draws 1.7 A, which is a very different supply. Expect somewhere between 0.5 and 1.5 amps<\/strong>, which is far beyond anything the Arduino can give and the reason the relay is here.<\/p>\n

The full procedure is on the lock\u2019s own page. Do it first.<\/p>\n

The lock must only ever be energised briefly<\/h3>\n

The coil has no thermal protection. Held on, it becomes too hot to touch within about a minute and can be damaged permanently.<\/p>\n

Every sketch here energises for one and a half seconds<\/strong> and has a hard ceiling checked independently<\/strong> of whatever decided to open the lock. If you take one habit from this project, take that one: on a part that can be destroyed by being left on, the limit must not consult the logic that might be wrong.<\/p>\n

3.3 volts, and a pin that looks ordinary<\/h3>\n

The RC522\u2019s supply pin is 3.3 V<\/strong>. Five volts there destroys the reader, and the pin sits in a row of eight that all look alike. Check it twice before powering up; this is the single most common way these modules die.<\/p>\n

Its SPI pins are 5 V signals going into a 3.3 V part, which works on a bench and is out of specification. For something that will live on a cabinet door, put a level converter on MOSI<\/code> and SCK<\/code>. Mixing 3.3 V and 5 V Safely<\/em> is the page.<\/p>\n

What happens at power-up, which is a safety question<\/h3>\n

When the board resets, every pin starts as a floating input. If the relay\u2019s resting level is the one that energises the lock, the lock pulses open at every reset \u2014 and on a cabinet lock that is a security hole you cannot see, because it lasts a fraction of a second.<\/p>\n

The sketch writes the resting level before<\/strong> pinMode()<\/code> makes the pin an output, which is the order that avoids the pulse. Test it deliberately: press the reset button with the lock connected and watch the bolt.<\/p>\n

How it works<\/h2>\n

The card list lives in EEPROM, so it survives a power cut, and three states keep the lock honest:<\/p>\n\n\n\n\n\n\n\n
State<\/th>\nWhat it means<\/th>\nWhat ends it<\/th>\n<\/tr>\n<\/thead>\n
IDLE<\/code><\/td>\nWaiting for a card<\/td>\nA card, or the release button<\/td>\n<\/tr>\n
OPEN<\/code><\/td>\nLock energised<\/td>\nThe open time, or the hard ceiling<\/td>\n<\/tr>\n
ENROLLING<\/code><\/td>\nMaster card presented; next card is added or removed<\/td>\nA card, or thirty seconds<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

The decision is deliberately boring:<\/p>\n

    \n
  1. A card arrives. Its UID is read.<\/li>\n
  2. If it is the master<\/strong> card, go to ENROLLING<\/code>.<\/li>\n
  3. If it is in the list, open.<\/li>\n
  4. If it is not, refuse \u2014 and if refusals keep coming, slow down.<\/li>\n
  5. Whatever happened, the lock closes on time.<\/li>\n<\/ol>\n

    Enrolment without a computer<\/h3>\n

    A cabinet whose card list can only be changed by editing a sketch is a cabinet you will stop using.<\/p>\n

    So one card is the master<\/strong>. Present it, and the next card presented is added to the list \u2014 or, if it is already in the list, removed from it. A beep pattern says which happened, and after thirty seconds with no card the mode gives up on its own.<\/p>\n

    The master card never opens the lock. That is a small decision with a real consequence: the card you carry to administer the thing is not the card you carry to use it, so losing one does not lose both.<\/p>\n

    Why the refusal counter exists, and what it does not fix<\/h3>\n

    After five refused cards in a row the project waits thirty seconds before reading another, and says so on its red LED.<\/p>\n

    Be clear about what this achieves. It makes trying thousands of random UIDs impractical. It does nothing<\/strong> against the real attack, which is cloning a card that is already accepted. It is worth the eight lines anyway, in the same way a lock on a garden gate is worth having, but it does not change the paragraph at the top of this page.<\/p>\n

    EEPROM, and writing to it sparingly<\/h3>\n

    An ATmega328P\u2019s EEPROM is good for roughly 100,000 writes per cell<\/strong>. That is plenty for a list that changes when somebody is given a card, and nothing like enough for something written every time the lock opens.<\/p>\n

    So the list is written only on enrolment, and the open count is not stored at all. If you want a log of every opening, that belongs on an SD card \u2014 see Making it yours<\/em>.<\/p>\n

    Build it in stages<\/h2>\n

    Stage 1: the reader, nothing else<\/h3>\n

    Wire the RC522 and run its tutorial\u2019s example. Present the card and the fob and write their UIDs down<\/strong>. You need one of them to be the master, and you cannot set the master without knowing a UID.<\/p>\n

    If the reader is not found, the cause is 3.3V<\/code> or a wrong SPI pin, in that order of likelihood.<\/p>\n

    Stage 2: the indicators<\/h3>\n

    Green LED, red LED and the buzzer, with the reader logic still just printing. Accepted and refused should be unmistakable across a room.<\/p>\n

    Stage 3: the relay and the lock, on the bench<\/h3>\n

    Wire the relay\u2019s control side only and hear it click. Then the load side, with the diode, with the lock\u2019s own supply, grounds joined.<\/p>\n

    Clamp the lock or hold it.<\/strong> It jumps when it fires, and the impulse is sharper than you expect.<\/p>\n

    Then press the Arduino\u2019s reset button, repeatedly, and watch the bolt. It must not move. If it twitches, your relay\u2019s resting level is wrong and the project is not ready for a cabinet door.<\/p>\n

    Stage 4: put it together<\/h3>\n

    The complete sketch below. Set MASTER_UID<\/code> to one of the UIDs you wrote down in stage 1.<\/p>\n

    Stage 5: fit it, and only to the right thing<\/h3>\n

    Four screws, a cabinet or a drawer, the striker plate aligned so the bolt drops in cleanly. Put the reader on the outside and everything else on the inside<\/strong>, including the release button \u2014 a release button on the outside is a lock with a button that opens it.<\/p>\n

    Pin reference<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
    Device<\/th>\nPin<\/th>\nConnect to<\/th>\nNotes<\/th>\n<\/tr>\n<\/thead>\n
    RC522<\/td>\n3.3V<\/code><\/td>\nUno 3.3V<\/code><\/strong><\/td>\nNever 5V<\/code><\/strong><\/td>\n<\/tr>\n
    RC522<\/td>\nGND<\/code><\/td>\nUno GND<\/code><\/td>\n<\/td>\n<\/tr>\n
    RC522<\/td>\nRST<\/code><\/td>\nUno D9<\/code><\/td>\n<\/td>\n<\/tr>\n
    RC522<\/td>\nSDA<\/code><\/td>\nUno D10<\/code><\/td>\nSPI chip select, not I2C<\/td>\n<\/tr>\n
    RC522<\/td>\nMOSI<\/code><\/td>\nUno D11<\/code><\/td>\nConverter for a permanent build<\/td>\n<\/tr>\n
    RC522<\/td>\nMISO<\/code><\/td>\nUno D12<\/code><\/td>\n<\/td>\n<\/tr>\n
    RC522<\/td>\nSCK<\/code><\/td>\nUno D13<\/code><\/td>\nConverter for a permanent build<\/td>\n<\/tr>\n
    Green LED<\/td>\nanode<\/td>\nUno D5<\/code><\/td>\nThrough 220 ohms<\/td>\n<\/tr>\n
    Red LED<\/td>\nanode<\/td>\nUno D6<\/code><\/td>\nThrough 220 ohms<\/td>\n<\/tr>\n
    Relay<\/td>\nIN<\/code><\/td>\nUno D7<\/code><\/td>\nLOW energises on this board<\/td>\n<\/tr>\n
    Relay<\/td>\nVCC<\/code>, GND<\/code><\/td>\nUno 5V<\/code>, GND<\/code><\/td>\n<\/td>\n<\/tr>\n
    Buzzer<\/td>\n+<\/code><\/td>\nUno D8<\/code><\/td>\n<\/td>\n<\/tr>\n
    Release button<\/td>\none leg<\/td>\nUno D2<\/code><\/td>\nINPUT_PULLUP<\/code>, inside<\/strong><\/td>\n<\/tr>\n
    Relay<\/td>\nCOM<\/code><\/td>\nLock supply +<\/code><\/td>\nLoad side<\/td>\n<\/tr>\n
    Relay<\/td>\nNO<\/code><\/td>\nLock red<\/td>\nLocked when unpowered<\/td>\n<\/tr>\n
    Lock<\/td>\nblack<\/td>\nLock supply -<\/code><\/td>\n<\/td>\n<\/tr>\n
    Diode<\/td>\nacross the lock<\/td>\nBanded end to red<\/td>\n1N4007, required<\/td>\n<\/tr>\n
    Lock supply<\/td>\n-<\/code><\/td>\nAlso Uno GND<\/code><\/strong><\/td>\nShared reference<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

    D13<\/code> is the SPI clock here, so the onboard LED flickers while the reader is being polled. That is the bus working, not a fault, and it is why the indicators are on D5<\/code> and D6<\/code>.<\/p>\n

    \"An
    Fail-secure, so it suits a cabinet and not a door people exit through. The card list lives in EEPROM.<\/figcaption><\/figure>\n

    The complete sketch<\/h2>\n
    \/\/ Siratek: an RFID cabinet lock.\n\/\/ See the top of the page for what a UID is and is not.\n\n#include <SPI.h>\n#include <MFRC522.h>\n#include <EEPROM.h>\n\nMFRC522 reader(10, 9);\n\nconst int greenPin  = 5;\nconst int redPin    = 6;\nconst int lockPin   = 7;\nconst int buzzerPin = 8;\nconst int buttonPin = 2;\n\n\/\/ Relay polarity: see Switching Bigger Loads with a Relay.\nconst int LOCK_ENERGISED = LOW;\nconst int LOCK_RESTING   = HIGH;\n\nconst unsigned long OPEN_FOR     = 1500;    \/\/ the bolt is in for this long\nconst unsigned long ABSOLUTE_MAX = 3000;    \/\/ and never longer than this\nconst unsigned long ENROL_WINDOW = 30000;\n\n\/\/ ---- From stage 1. The master administers; it never opens. ----\nconst byte MASTER_UID[4] = {0xDE, 0xAD, 0xBE, 0xEF};\n\/\/ ---------------------------------------------------------------\n\n\/\/ EEPROM layout: a marker, a count, then up to 8 four-byte UIDs.\nconst int EEPROM_MARKER_ADDR = 0;\nconst int EEPROM_COUNT_ADDR  = 1;\nconst int EEPROM_LIST_ADDR   = 2;\nconst byte MARKER = 0x5A;\nconst int MAX_CARDS = 8;\n\nenum State { IDLE, OPEN, ENROLLING };\nState state = IDLE;\nunsigned long stateSince = 0;\n\nint refusals = 0;\nunsigned long lockedOutUntil = 0;\n\nvoid beep(int times, int lengthMs) {\n  for (int i = 0; i < times; i++) {\n    digitalWrite(buzzerPin, HIGH);\n    delay(lengthMs);\n    digitalWrite(buzzerPin, LOW);\n    if (i < times - 1) {\n      delay(lengthMs);\n    }\n  }\n}\n\nbyte cardCount() {\n  if (EEPROM.read(EEPROM_MARKER_ADDR) != MARKER) {\n    return 0;                       \/\/ never initialised\n  }\n  byte n = EEPROM.read(EEPROM_COUNT_ADDR);\n  return n > MAX_CARDS ? 0 : n;\n}\n\nvoid readCard(byte index, byte out[4]) {\n  for (byte i = 0; i < 4; i++) {\n    out[i] = EEPROM.read(EEPROM_LIST_ADDR + index * 4 + i);\n  }\n}\n\nbool sameUid(const byte a[4], const byte b[4]) {\n  for (byte i = 0; i < 4; i++) {\n    if (a[i] != b[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n\/\/ -1 if not in the list, otherwise its index.\nint findCard(const byte uid[4]) {\n  byte n = cardCount();\n  byte stored[4];\n  for (byte i = 0; i < n; i++) {\n    readCard(i, stored);\n    if (sameUid(stored, uid)) {\n      return i;\n    }\n  }\n  return -1;\n}\n\nbool addCard(const byte uid[4]) {\n  byte n = cardCount();\n  if (n >= MAX_CARDS) {\n    return false;\n  }\n  for (byte i = 0; i < 4; i++) {\n    EEPROM.update(EEPROM_LIST_ADDR + n * 4 + i, uid[i]);\n  }\n  EEPROM.update(EEPROM_COUNT_ADDR, n + 1);\n  EEPROM.update(EEPROM_MARKER_ADDR, MARKER);\n  return true;\n}\n\nvoid removeCard(int index) {\n  byte n = cardCount();\n  byte moved[4];\n  \/\/ Move the last one into the gap, then shorten the list.\n  if (index != n - 1) {\n    readCard(n - 1, moved);\n    for (byte i = 0; i < 4; i++) {\n      EEPROM.update(EEPROM_LIST_ADDR + index * 4 + i, moved[i]);\n    }\n  }\n  EEPROM.update(EEPROM_COUNT_ADDR, n - 1);\n}\n\nvoid release() {\n  digitalWrite(lockPin, LOCK_RESTING);\n  digitalWrite(greenPin, LOW);\n  state = IDLE;\n  stateSince = millis();\n}\n\nvoid openLock(const __FlashStringHelper* why) {\n  if (state == OPEN) {\n    return;                         \/\/ already open; do not extend it\n  }\n  state = OPEN;\n  stateSince = millis();\n  digitalWrite(lockPin, LOCK_ENERGISED);\n  digitalWrite(greenPin, HIGH);\n  beep(1, 80);\n  Serial.print(F(\"open: \"));\n  Serial.println(why);\n}\n\nvoid refuse() {\n  refusals++;\n  digitalWrite(redPin, HIGH);\n  beep(2, 60);\n  delay(400);\n  digitalWrite(redPin, LOW);\n\n  Serial.print(F(\"refused (\"));\n  Serial.print(refusals);\n  Serial.println(F(\")\"));\n\n  if (refusals >= 5) {\n    lockedOutUntil = millis() + 30000UL;\n    refusals = 0;\n    Serial.println(F(\"too many refusals: pausing for 30 seconds\"));\n  }\n}\n\nvoid setup() {\n  \/\/ The resting level FIRST, so the lock cannot pulse on at reset.\n  digitalWrite(lockPin, LOCK_RESTING);\n  pinMode(lockPin, OUTPUT);\n\n  pinMode(greenPin, OUTPUT);\n  pinMode(redPin, OUTPUT);\n  pinMode(buzzerPin, OUTPUT);\n  pinMode(buttonPin, INPUT_PULLUP);\n\n  Serial.begin(9600);\n  SPI.begin();\n  reader.PCD_Init();\n\n  Serial.print(F(\"Siratek: cabinet lock. Cards enrolled: \"));\n  Serial.println(cardCount());\n  stateSince = millis();\n}\n\nvoid loop() {\n  \/\/ 1. The limits. Checked before anything else, and they read only the clock.\n  if (state == OPEN && millis() - stateSince >= OPEN_FOR) {\n    release();\n    Serial.println(F(\"closed\"));\n  }\n  if (state == OPEN && millis() - stateSince >= ABSOLUTE_MAX) {\n    release();\n    Serial.println(F(\"closed: absolute limit\"));\n  }\n\n  \/\/ 2. Enrolment gives up on its own.\n  if (state == ENROLLING && millis() - stateSince >= ENROL_WINDOW) {\n    state = IDLE;\n    digitalWrite(redPin, LOW);\n    Serial.println(F(\"enrolment timed out\"));\n  }\n\n  \/\/ 3. The release button, on the inside.\n  if (digitalRead(buttonPin) == LOW && state != OPEN) {\n    openLock(F(\"release button\"));\n    return;\n  }\n\n  \/\/ 4. Refusal lockout.\n  if (millis() < lockedOutUntil) {\n    digitalWrite(redPin, (millis() % 1000) < 500);\n    return;\n  }\n\n  \/\/ 5. A card, or nothing.\n  if (!reader.PICC_IsNewCardPresent() || !reader.PICC_ReadCardSerial()) {\n    return;\n  }\n\n  if (reader.uid.size != 4) {\n    \/\/ Seven-byte UIDs are common on newer cards and phones. This list\n    \/\/ holds four-byte ones, and comparing only the first four would\n    \/\/ accept cards it should not.\n    Serial.println(F(\"refused: not a 4-byte UID\"));\n    refuse();\n    reader.PICC_HaltA();\n    reader.PCD_StopCrypto1();\n    return;\n  }\n\n  byte uid[4];\n  for (byte i = 0; i < 4; i++) {\n    uid[i] = reader.uid.uidByte[i];\n  }\n\n  if (state == ENROLLING) {\n    int found = findCard(uid);\n    if (found >= 0) {\n      removeCard(found);\n      beep(3, 70);\n      Serial.println(F(\"card removed\"));\n    } else if (addCard(uid)) {\n      beep(2, 150);\n      Serial.println(F(\"card added\"));\n    } else {\n      beep(5, 50);\n      Serial.println(F(\"list full\"));\n    }\n    state = IDLE;\n    digitalWrite(redPin, LOW);\n\n  } else if (sameUid(uid, MASTER_UID)) {\n    state = ENROLLING;\n    stateSince = millis();\n    digitalWrite(redPin, HIGH);\n    beep(1, 300);\n    Serial.println(F(\"master: present a card to add or remove it\"));\n\n  } else if (findCard(uid) >= 0) {\n    refusals = 0;\n    openLock(F(\"known card\"));\n\n  } else {\n    refuse();\n  }\n\n  reader.PICC_HaltA();\n  reader.PCD_StopCrypto1();\n}<\/code><\/pre>\n
    Five decisions worth explaining<\/h3>\n
    The resting level is written before pinMode()<\/code>.<\/strong> One line in an unusual order, and it is the difference between a cabinet that stays shut through a reset and one that flicks open every time the power wavers. Test it rather than trusting it.<\/p>\n
    Two independent time limits.<\/strong> OPEN_FOR<\/code> is the normal one; ABSOLUTE_MAX<\/code> exists in case something is wrong with the first. On a coil that can be destroyed by being left on, that redundancy costs four lines.<\/p>\n
    openLock()<\/code> refuses to extend an open that is already running.<\/strong> Without that, a card held against the reader or a stuck button would keep pushing the timestamp forward and the lock would stay energised indefinitely \u2014 exactly what must not happen.<\/p>\n
    The limits are the first thing in loop()<\/code>, before the button and before the reader.<\/strong> So a card presented during an open cannot delay the close, and neither can anything else.<\/p>\n
    EEPROM.update()<\/code>, not EEPROM.write()<\/code>.<\/strong> update()<\/code> only writes when the byte is actually different, which matters on a part rated for about 100,000 writes per cell.<\/p>\n
    Testing it<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
    Try this<\/th>\nIt should<\/th>\n<\/tr>\n<\/thead>\n
    Press the Arduino\u2019s reset with the lock connected<\/strong><\/td>\nThe bolt must not move at all<\/td>\n<\/tr>\n
    Present an unknown card<\/td>\nRed, two beeps, nothing opens<\/td>\n<\/tr>\n
    Present the master, then an unknown card<\/td>\nTwo long beeps: added<\/td>\n<\/tr>\n
    Present that card<\/td>\nOpens<\/td>\n<\/tr>\n
    Present the master, then that same card<\/td>\nThree beeps: removed<\/td>\n<\/tr>\n
    Present it again<\/td>\nRefused<\/td>\n<\/tr>\n
    Unplug everything, plug it back in<\/td>\nThe list is still there; the count prints at startup<\/td>\n<\/tr>\n
    Present the master card alone<\/td>\nEnrolment mode, then it gives up after thirty seconds<\/td>\n<\/tr>\n
    Hold a known card against the reader<\/td>\nOpens once, closes on time, does not re-open while held<\/td>\n<\/tr>\n
    Five unknown cards in a row<\/td>\nRed blinks, reader ignored for thirty seconds<\/td>\n<\/tr>\n
    Press the release button<\/td>\nOpens<\/td>\n<\/tr>\n
    Energise it, then pull the lock\u2019s supply<\/strong><\/td>\nThe bolt springs out at once: fail-secure<\/td>\n<\/tr>\n
    Feel the lock after ten operations<\/td>\nCool. Warm means the limits are not working<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
    The first and the last-but-one are the two that matter. One proves the lock cannot be opened by interrupting the power; the other proves it closes when the power goes. Both are properties of the build rather than the code, and both are worth demonstrating to whoever will use the cabinet.<\/p>\n
    Making it yours<\/h2>\n
      \n
    • Log every opening.<\/strong> The SD card module and the DS3231 give a dated line per card, which is the single most useful addition: not security, but a genuine record of who opened what and when. Project, a Standalone Data Logger<\/em> is the pattern, and it keeps those writes off the EEPROM.<\/li>\n
    • Add a keypad.<\/strong> A card and<\/em> a four-digit code is meaningfully better than a card alone, because cloning the card is then not enough. The 4\u00d74 keypad page covers it.<\/li>\n
    • A fingerprint sensor instead.<\/strong> Nothing to clone and nothing to lose, with its own limits set out on its page. The lock side of this project is unchanged.<\/li>\n
    • Show something.<\/strong> A 16\u00d72 I2C LCD saying \u201cpresent card\u201d, \u201cwelcome\u201d or \u201cenrolment\u201d makes the project explain itself to someone who has never seen it.<\/li>\n
    • Put the reader on a door and the brain inside.<\/strong> A long cable to the reader is the right arrangement; a long cable to the lock is not, because a cut cable at the lock end is a way in.<\/li>\n<\/ul>\n
      What not to do: fit this to a room door, a front door, or anything on an escape route. Fail-secure plus a spring latch plus a cloneable card is the wrong combination for all three.<\/p>\n
      Troubleshooting<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
      Symptom<\/th>\nLikely cause<\/th>\nCheck or fix<\/th>\n<\/tr>\n<\/thead>\n
      Reader not found at startup<\/td>\n3.3V<\/code>, or SPI wiring<\/td>\nNever 5V<\/code>; SDA<\/code> is D10<\/code>, RST<\/code> is D9<\/code><\/td>\n<\/tr>\n
      Reader worked once, now dead<\/td>\n5 V applied to it<\/td>\nThat board is 3.3 V only<\/td>\n<\/tr>\n
      Cards read intermittently<\/td>\nPCD_StopCrypto1()<\/code> missing<\/td>\nIt is at the end of every path<\/td>\n<\/tr>\n
      Bolt twitches at reset<\/td>\nResting level set after pinMode<\/code><\/td>\nWrite it before<\/td>\n<\/tr>\n
      Nothing moves, relay clicks<\/td>\nLock supply voltage or current<\/td>\nMeasure at the lock\u2019s own wires<\/td>\n<\/tr>\n
      Bolt moves weakly<\/td>\nSupply sagging<\/td>\n0.5 to 1.5 A; measure the coil first<\/td>\n<\/tr>\n
      Lock gets hot<\/td>\nHeld energised<\/td>\nThe two limits exist for this; check both<\/td>\n<\/tr>\n
      Lock hot despite the limits<\/td>\nSomething calls openLock()<\/code> repeatedly<\/td>\nIt refuses to extend; check the call sites<\/td>\n<\/tr>\n
      Arduino resets when the lock fires<\/td>\nShared supply<\/td>\nSeparate supply, grounds joined<\/td>\n<\/tr>\n
      Relay contacts pit quickly<\/td>\nNo flyback diode<\/td>\n1N4007, banded end to the positive side<\/td>\n<\/tr>\n
      Card list lost after a power cut<\/td>\nEEPROM marker never written<\/td>\naddCard()<\/code> writes it; enrol one card<\/td>\n<\/tr>\n
      Master card opens the lock<\/td>\nIt is also in the list<\/td>\nRemove it; the master administers only<\/td>\n<\/tr>\n
      A phone or newer card is refused<\/td>\nSeven-byte UID<\/td>\nBy design; the list holds four-byte ones<\/td>\n<\/tr>\n
      Door locked after a power cut<\/td>\nFail-secure, as designed<\/td>\nDo not use this on a door people exit through<\/td>\n<\/tr>\n
      Someone opened it with a copied card<\/td>\nThe honest limit of this project<\/td>\nSee the top of the page<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
      Sources and attribution<\/h2>\n
      All text, wiring guidance and code in this project are original Siratek work.<\/p>\n
        \n
      • Reader behaviour, the 3.3 V supply limit, the SPI pin assignment, the UID length check, the PCD_StopCrypto1()<\/code> requirement and the honest account of what a UID is and is not are as set out in Reading RFID Cards with an RC522<\/em>, which cites the published research on MIFARE Classic.<\/li>\n
      • The lock\u2019s momentary duty, its absent voltage marking and the measurement method, the flyback diode and the fail-secure consequences are as set out in A Mini Electronic Lock<\/em>, read from the Siratek product photographs for item 2795.<\/li>\n
      • Relay switching and the startup behaviour are as set out in Switching Bigger Loads with a Relay<\/em>.<\/li>\n
      • The EEPROM card list, the master-card enrolment scheme, the refusal lockout and the two independent time limits are Siratek\u2019s own design decisions for this project. The roughly 100,000 write endurance figure is the ATmega328P datasheet\u2019s.<\/li>\n<\/ul>\n
        This project has not yet been built and run on hardware<\/strong>, and the lock\u2019s supply voltage is a measurement the builder must take rather than a figure this page can give. The limits on what this project is suitable for are stated at the top and are not softened anywhere below. No third-party tutorial text, diagrams, photographs or code has been reproduced here.<\/p>\n
        <\/p>\n<\/body>","protected":false},"excerpt":{"rendered":"
        A cabinet that opens when you present a card. A reader on the outside, a solenoid latch on the inside, a release button, and a list of accepted cards that survives being unplugged \u2014 with a master card that adds…<\/p>\n","protected":false},"featured_media":0,"template":"","siratek_tutorial_level":[],"class_list":["post-52340","siratek_tutorial","type-siratek_tutorial","status-publish","hentry"],"yoast_head":"\nProject, an RFID Door Lock - siratek<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"http:\/\/siratek.net\/index.php\/tutorials\/rfid-door-lock\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Project, an RFID Door Lock - siratek\" \/>\n<meta property=\"og:description\" content=\"A cabinet that opens when you present a card. A reader on the outside, a solenoid latch on the inside, a release button, and a list of accepted cards that survives being unplugged \u2014 with a master card that adds...\" \/>\n<meta property=\"og:url\" content=\"http:\/\/siratek.net\/index.php\/tutorials\/rfid-door-lock\/\" \/>\n<meta property=\"og:site_name\" content=\"siratek\" \/>\n<meta property=\"og:image\" content=\"http:\/\/siratek.net\/wp-content\/uploads\/2026\/11\/rfid-door-lock-wiring.svg\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data1\" content=\"17 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"http:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/rfid-door-lock\\\/\",\"url\":\"http:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/rfid-door-lock\\\/\",\"name\":\"Project, an RFID Door Lock - siratek\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/siratek.net\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"http:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/rfid-door-lock\\\/#primaryimage\"},\"image\":{\"@id\":\"http:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/rfid-door-lock\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/siratek.net\\\/wp-content\\\/uploads\\\/2026\\\/11\\\/rfid-door-lock-wiring.svg\",\"datePublished\":\"2026-11-01T10:50:59+00:00\",\"breadcrumb\":{\"@id\":\"http:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/rfid-door-lock\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"http:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/rfid-door-lock\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"http:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/rfid-door-lock\\\/#primaryimage\",\"url\":\"https:\\\/\\\/siratek.net\\\/wp-content\\\/uploads\\\/2026\\\/11\\\/rfid-door-lock-wiring.svg\",\"contentUrl\":\"https:\\\/\\\/siratek.net\\\/wp-content\\\/uploads\\\/2026\\\/11\\\/rfid-door-lock-wiring.svg\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"http:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/rfid-door-lock\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/siratek.net\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Tutorials\",\"item\":\"https:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Project, an RFID Door Lock\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/siratek.net\\\/#website\",\"url\":\"https:\\\/\\\/siratek.net\\\/\",\"name\":\"siratek\",\"description\":\"Your Best Electronic Retail Shop\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/siratek.net\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Project, an RFID Door Lock - siratek","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"http:\/\/siratek.net\/index.php\/tutorials\/rfid-door-lock\/","og_locale":"en_US","og_type":"article","og_title":"Project, an RFID Door Lock - siratek","og_description":"A cabinet that opens when you present a card. A reader on the outside, a solenoid latch on the inside, a release button, and a list of accepted cards that survives being unplugged \u2014 with a master card that adds...","og_url":"http:\/\/siratek.net\/index.php\/tutorials\/rfid-door-lock\/","og_site_name":"siratek","og_image":[{"url":"http:\/\/siratek.net\/wp-content\/uploads\/2026\/11\/rfid-door-lock-wiring.svg","type":"","width":"","height":""}],"twitter_card":"summary_large_image","twitter_misc":{"Est. reading time":"17 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"http:\/\/siratek.net\/index.php\/tutorials\/rfid-door-lock\/","url":"http:\/\/siratek.net\/index.php\/tutorials\/rfid-door-lock\/","name":"Project, an RFID Door Lock - siratek","isPartOf":{"@id":"https:\/\/siratek.net\/#website"},"primaryImageOfPage":{"@id":"http:\/\/siratek.net\/index.php\/tutorials\/rfid-door-lock\/#primaryimage"},"image":{"@id":"http:\/\/siratek.net\/index.php\/tutorials\/rfid-door-lock\/#primaryimage"},"thumbnailUrl":"http:\/\/siratek.net\/wp-content\/uploads\/2026\/11\/rfid-door-lock-wiring.svg","datePublished":"2026-11-01T10:50:59+00:00","breadcrumb":{"@id":"http:\/\/siratek.net\/index.php\/tutorials\/rfid-door-lock\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["http:\/\/siratek.net\/index.php\/tutorials\/rfid-door-lock\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"http:\/\/siratek.net\/index.php\/tutorials\/rfid-door-lock\/#primaryimage","url":"https:\/\/siratek.net\/wp-content\/uploads\/2026\/11\/rfid-door-lock-wiring.svg","contentUrl":"https:\/\/siratek.net\/wp-content\/uploads\/2026\/11\/rfid-door-lock-wiring.svg"},{"@type":"BreadcrumbList","@id":"http:\/\/siratek.net\/index.php\/tutorials\/rfid-door-lock\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/siratek.net\/"},{"@type":"ListItem","position":2,"name":"Tutorials","item":"https:\/\/siratek.net\/index.php\/tutorials\/"},{"@type":"ListItem","position":3,"name":"Project, an RFID Door Lock"}]},{"@type":"WebSite","@id":"https:\/\/siratek.net\/#website","url":"https:\/\/siratek.net\/","name":"siratek","description":"Your Best Electronic Retail Shop","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/siratek.net\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"}]}},"jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/siratek.net\/index.php\/wp-json\/wp\/v2\/siratek_tutorial\/52340","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/siratek.net\/index.php\/wp-json\/wp\/v2\/siratek_tutorial"}],"about":[{"href":"https:\/\/siratek.net\/index.php\/wp-json\/wp\/v2\/types\/siratek_tutorial"}],"version-history":[{"count":0,"href":"https:\/\/siratek.net\/index.php\/wp-json\/wp\/v2\/siratek_tutorial\/52340\/revisions"}],"wp:attachment":[{"href":"https:\/\/siratek.net\/index.php\/wp-json\/wp\/v2\/media?parent=52340"}],"wp:term":[{"taxonomy":"siratek_tutorial_level","embeddable":true,"href":"https:\/\/siratek.net\/index.php\/wp-json\/wp\/v2\/siratek_tutorial_level?post=52340"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}