IoT og smarthus

RFID-lås med M5Stack og ESP32: tre prosjekter med kode

Fotorealistisk illustrasjon av en svart M5StickS3 som viser «Hei, Kari!», koblet til en hvit RFID-leser der det ligger en blå nøkkelbrikke

Hold en nøkkelbrikke mot leseren. Skjermen svarer «Hei, Kari!», og låsebolten trekker seg inn med et klikk. I denne guiden bygger du en RFID-lås, en enkel adgangskontroll, i tre nivåer: først bare gjenkjenning med navn og ikon på en M5StickS3, så en elektrisk lås på 12 V, og til slutt en lås på ESP32 som Home Assistant styrer med tidsregler og logg. All koden står her, og hvert nivå virker for seg.

Resultatet av de tre nivåene i RFID-låsen: navn og ikon på skjermen, en lås som åpner seg, og styring fra Home Assistant.
Slik kan de tre nivåene se ut. Dette er en tegning. Nivå 1: brikken leses, og skjermen viser navn og ikon. Nivå 2: samme skjerm, men nå trekker et relé inn bolten på en 12 V-lås. Nivå 3: RC522 og OLED-skjerm på ESP32, mens Home Assistant bestemmer hvem som slipper inn, og fører logg.
Nivå
Nybegynner til avansert
Tid
30 minutter, halvannen time og en ettermiddag
Lodding
Bare i nivå 3: én pinnerad på RC522
Spenning
5 V fra USB og 12 V til låsen
Du lærer
UID, I2C og SPI, relé med friløpsdiode, ESPHome og tagger i Home Assistant
Kort forklartEn RFID-lås har tre deler: en leser som henter UID-en fra brikken, et program som sammenligner UID-en med en liste, og et relé som slipper 12 V til en elektrisk lås i noen sekunder. Leseren og brikkene her bruker 13,56 MHz (MIFARE). UID-en er ikke hemmelig og kan kopieres. Derfor passer låsen til skap, skuffer og innerdører, ikke som eneste lås på ytterdøren.

Dette trenger du

Nivå 1 klarer seg med de to øverste delene og en brikke. Nivå 2 legger til lås, relé og strøm. Nivå 3 flytter styringen til en ESP32 og gjenbruker låsekretsen fra nivå 2. Vil du først forstå teknologien bak, forklarer guiden om RFID og NFC frekvenser, brikketyper og alle leserne i butikken.

  • M5StickS3, MR-008791 stk, nivå 1 og 2: styring, skjerm og høyttaler i ett
    kr 489,00
    På lager
  • M5Stack Unit RFID 2 med rød Grove-kontakt
    M5Stack Unit RFID 2, MR-015201 stk, nivå 1 og 2: leser på 13,56 MHz med Grove-kabel i esken
    kr 275,00
    På lager
  • Ti blå RFID-nøkkelbrikker
    Nøkkelbrikker 13,56 MHz, 10 stk, MR-00981Alle nivåer: én brikke per person
    kr 189,00
    På lager
  • Hvite RFID-kort i kredittkortformat
    RFID-kort 13,56 MHz, 10 stk, MR-00983Alle nivåer: kort i bankkortstørrelse
    kr 269,00
    På lager
  • Enkanals relémodul med blått relé og skruterminal
    Relémodul 1 kanal 5 V, MR-016281 stk, nivå 2 og 3: bryteren som slipper 12 V til låsen
    kr 79,00
    På lager
  • Elektrisk lås med skrå låsebolt og festeplate
    Elektrisk lås 12 V med låsebolt, MR-018261 stk, nivå 2 og 3: bolten trekkes inn når låsen får strøm
    kr 299,00
    På lager
  • Strømforsyning 12 V 2,5 A, MR-007641 stk, nivå 2 og 3: strøm til låsen
    kr 239,00
    På lager
  • DC-modul med rund strømkontakt og fire pinner
    DC-modul med 5,5 × 2,1 mm-kontakt, MR-012881 stk, nivå 2 og 3: gjør pluggen fra strømforsyningen om til pinner
    kr 79,00
    På lager
  • Ti dioder 1N4007 på tape
    Diode 1N4007, 10 stk, MR-017811 stk, nivå 2 og 3: friløpsdiode over låsen
    kr 25,00
    På lager
  • Lite hvitt koblingsbrett med 170 hull
    Lite koblingsbrett, 170 hull, MR-012781 stk i nivå 2, 3 stk i nivå 3
    kr 49,00
    På lager
  • Sett med fleksible koblingsledninger i regnbuefarger med hann- og hunnkontakter
    Koblingsledninger 20 cm, 120 stk, MR-00450Nivå 2 og 3: 40 hann-hunn til pinner og kontakter, 40 hann-hann til koblingsbrett og skruterminaler, 40 hunn-hunn i reserve
    kr 169,00
    På lager
  • kr 369,00
    På lager
  • RC522-leser med hvitt kort og blå nøkkelbrikke
    RC522-sett med kort og nøkkelbrikke, MR-005411 stk, nivå 3: leseren, pinnerad som må loddes, ett kort og én brikke
    kr 139,00
    På lager
  • OLED-skjerm 0,96" I2C, MR-016361 stk, nivå 3: viser hva låsen gjør
    kr 165,00
    På lager
  • Aktiv summermodul, MR-009501 stk, nivå 3: lydsignal
    kr 95,00
    På lager
  • Åpen sortimentsboks med lysdioder og motstander
    LED-sett med 1 kΩ-motstander, MR-014501 grønn LED og 1 motstand, nivå 3
    kr 179,00
    På lager

I tillegg trenger du en USB-C-kabel til M5StickS3, en mikro-USB-kabel til ESP32 og en liten skrutrekker til skruterminalene på reléet. Mangler du koblingsledninger av riktig type, finner du flere under koblingsledninger, og flere brett under koblingsbrett og prototyping.

Slik virker en RFID-lås

Brikken har ikke batteri. Den får strøm fra feltet til leseren når den er noen centimeter unna, og svarer med et nummer som heter UID. På brikkene her er UID-en fire byte, og du skriver den som åtte tegn, for eksempel 04A1B2C3. Programmet ditt gjør resten: det slår opp UID-en i en liste og bestemmer hva som skal skje.

Nivå 1: skjermen kjenner deg igjen

Nivå 1: nybegynner. Tid: rundt 30 minutter. Du trenger M5StickS3, Unit RFID 2 med Grove-kabelen som følger med, og noen nøkkelbrikker eller kort. Ingen lodding og ingen løse ledninger.

M5StickS3 er en ESP32-S3 med skjerm, knapper, høyttaler og batteri i et hus på størrelse med en minnepinne. Unit RFID 2 er leseren. De snakker sammen over I2C, og hele koblingen er én kabel.

M5StickS3 og M5Stack Unit RFID 2 koblet sammen med Grove-kabel, med en nøkkelbrikke holdt over leseren.
Forenklet tegning, sett ovenfra. Grove-kabelen har fire ledere: svart er GND, rød er 5 V, gul er G9 (SDA) og hvit er G10 (SCL). Antennen ligger under symbolet på leseren, og brikken må nærmere enn 20 mm.

Koble til og gjør klar Arduino IDE

  1. Sett Grove-kabelen i den røde kontakten på Unit RFID 2 og i Grove-porten på enden av M5StickS3. Pluggen går bare inn én vei.
  2. Koble M5StickS3 til PC-en med USB-C.
  3. Installer kortpakken «M5Stack» i Arduino IDE og velg kortet M5StickS3. Har du ikke gjort det før, viser guiden om å programmere ESP32 og M5Stack hvert klikk.
  4. Åpne Library Manager og installer M5Unified (0.3.0 eller nyere) og MFRC522_I2C.
  5. Lim inn programmet under og last det opp.

Finner du ikke MFRC522_I2C i Library Manager, laster du ned ZIP-filen fra prosjektet på GitHub og velger Sketch > Include Library > Add .ZIP Library.

Programmet for nivå 1

// Nivå 1: M5StickS3 + M5Stack Unit RFID 2 (WS1850S, I2C 0x28)
// Viser navn og ikon på skjermen når en kjent brikke eller et kjent kort holdes mot leseren.
// Biblioteker: M5Unified (0.3.0 eller nyere) og MFRC522_I2C (1.0).

#include <M5Unified.h>
#include <Wire.h>
#include <MFRC522_I2C.h>

MFRC522_I2C rfid(0x28, -1);  // I2C-adresse 0x28, ingen reset-pinne

enum Ikon : uint8_t { SMIL, STJERNE, HJERTE };

struct Bruker {
  const char* uid;   // UID med store bokstaver, uten mellomrom
  const char* navn;
  Ikon ikon;
};

// Bytt ut UID-ene med dine egne. Skjermen viser UID-en til en ukjent brikke.
const Bruker brukere[] = {
  { "04A1B2C3", "Kari", SMIL },
  { "53D4E5F6", "Bjørn", STJERNE },
  { "A7B8C9D0", "Nora", HJERTE },
};

const uint32_t VIS_MS = 3000;  // hvor lenge svaret står på skjermen
uint32_t visTil = 0;

String lesUid() {
  String uid;
  for (uint8_t i = 0; i < rfid.uid.size; i++) {
    if (rfid.uid.uidByte[i] < 0x10) uid += '0';
    uid += String(rfid.uid.uidByte[i], HEX);
  }
  uid.toUpperCase();
  return uid;
}

void tegnIkon(Ikon ikon, int x, int y) {
  auto& d = M5.Display;
  switch (ikon) {
    case SMIL:
      d.fillCircle(x, y, 36, TFT_YELLOW);
      d.fillCircle(x - 13, y - 10, 5, TFT_BLACK);
      d.fillCircle(x + 13, y - 10, 5, TFT_BLACK);
      d.fillArc(x, y + 4, 22, 18, 20, 160, TFT_BLACK);
      break;
    case STJERNE:
      d.fillTriangle(x, y - 38, x - 33, y + 19, x + 33, y + 19, TFT_YELLOW);
      d.fillTriangle(x, y + 38, x - 33, y - 19, x + 33, y - 19, TFT_YELLOW);
      break;
    case HJERTE:
      d.fillCircle(x - 17, y - 10, 19, TFT_RED);
      d.fillCircle(x + 17, y - 10, 19, TFT_RED);
      d.fillTriangle(x - 35, y - 2, x + 35, y - 2, x, y + 36, TFT_RED);
      break;
  }
}

void visVent() {
  auto& d = M5.Display;
  d.fillScreen(TFT_BLACK);
  d.setTextColor(TFT_WHITE);
  d.setTextDatum(middle_center);
  d.setFont(&fonts::efontJA_24_b);
  d.drawString("Hold brikken", d.width() / 2, 48);
  d.drawString("mot leseren", d.width() / 2, 86);
}

void visKjent(const Bruker& b) {
  auto& d = M5.Display;
  d.fillScreen(d.color565(0, 90, 40));
  tegnIkon(b.ikon, 50, d.height() / 2);
  d.setTextColor(TFT_WHITE);
  d.setTextDatum(middle_left);
  d.setFont(&fonts::efontJA_16);
  d.drawString("Identifisert", 104, 34);
  d.setFont(&fonts::efontJA_24_b);
  d.drawString("Hei,", 104, 66);
  d.drawString(String(b.navn) + "!", 104, 100);
  M5.Speaker.tone(1760, 120);
}

void visUkjent(const String& uid) {
  auto& d = M5.Display;
  d.fillScreen(d.color565(130, 0, 0));
  d.setTextColor(TFT_WHITE);
  d.setTextDatum(middle_center);
  d.setFont(&fonts::efontJA_24_b);
  d.drawString("Ukjent brikke", d.width() / 2, 44);
  d.setFont(&fonts::efontJA_16);
  d.drawString("UID: " + uid, d.width() / 2, 92);
  M5.Speaker.tone(220, 400);
}

void setup() {
  auto cfg = M5.config();
  cfg.output_power = true;  // 5 V ut på Grove-porten, som leseren får strøm fra
  M5.begin(cfg);
  M5.Power.setExtOutput(true);
  M5.Display.setRotation(1);  // liggende, 240 x 135 piksler
  M5.Speaker.setVolume(120);
  Serial.begin(115200);

  // Grove-porten på M5StickS3: SDA = G9 (gul), SCL = G10 (hvit)
  Wire.begin(M5.getPin(m5::pin_name_t::port_a_sda), M5.getPin(m5::pin_name_t::port_a_scl), 400000U);
  delay(100);
  rfid.PCD_Init();
  visVent();
}

void loop() {
  M5.update();

  if (visTil != 0 && millis() > visTil) {
    visTil = 0;
    visVent();
  }

  if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) {
    delay(50);
    return;
  }

  String uid = lesUid();
  Serial.println("UID: " + uid);

  const Bruker* funnet = nullptr;
  for (const Bruker& b : brukere) {
    if (uid == b.uid) funnet = &b;
  }

  if (funnet) {
    visKjent(*funnet);
  } else {
    visUkjent(uid);
  }
  visTil = millis() + VIS_MS;

  rfid.PICC_HaltA();  // be brikken være stille til den tas bort og holdes inntil på nytt
}

Merk deg tre ting. cfg.output_power = true og M5.Power.setExtOutput(true) slår på 5 V ut på Grove-porten, og derfra får leseren strøm. Den andre linjen gjør det samme en gang til, slik at strømmen er på selv om du endrer oppsettet. Wire.begin henter pinnene fra M5Unified, så du slipper å huske at Grove-porten bruker G9 og G10. Og PICC_HaltA() ber brikken tie stille, slik at samme brikke ikke leses på nytt før du tar den bort og holder den inntil igjen.

Finn UID-en til brikkene dine

Programmet kjenner ikke brikkene dine ennå. Hold en brikke mot leseren. Skjermen blir rød og viser UID-en. Skriv den inn i listen brukere[] sammen med et navn og et ikon, og last opp på nytt. Navn med æ, ø og å virker, fordi skriften efontJA_24_b har de tegnene.

Skjermbildene i nivå 1 på M5StickS3: venter på brikke, kjent brikke med smilefjes og navn, ukjent brikke med UID.
Slik skal skjermen se ut. Navn og UID er eksempler. Svart skjerm betyr at leseren venter. Grønn skjerm med ikon betyr at brikken står i listen. Rød skjerm viser UID-en til en brikke som ikke står der, og det er den du skriver inn i listen.
UID: 04A1B2C3
UID: 9C41E27A

Hvis det ikke virker

Skjermen viser «Hold brikken mot leseren», men ingenting skjer

Sjekk at Grove-kabelen sitter helt inne i begge ender, og at cfg.output_power = true står i setup(). Hold brikken flatt mot symbolet på leseren, helt inntil. Blå nøkkelbrikker og hvite kort på 13,56 MHz virker. Brikker på 125 kHz ser like ut, men virker ikke med denne leseren.

Teksten står opp ned

Bytt setRotation(1) til setRotation(3). Da snur du bildet en halv omdreining, og du kan legge M5StickS3 den veien som passer kabelen.

Kompileringen stopper på MFRC522_I2C.h

Biblioteket er ikke installert. Installer det fra Library Manager eller som ZIP-fil, og start Arduino IDE på nytt.

Test deg selv: hvorfor viser skjermen UID-en til ukjente brikker?

Fordi du trenger den for å legge brikken inn i listen. Det viser også noe viktig om sikkerheten: UID-en er ikke hemmelig. Enhver leser kan hente den.

Nivå 2: brikken åpner en elektrisk lås

Nivå 2: viderekommen. Tid: rundt halvannen time. Du trenger oppsettet fra nivå 1 og i tillegg relémodulen, låsen på 12 V, strømforsyningen på 12 V, DC-modulen, én 1N4007, et lite koblingsbrett og koblingsledninger.

Låsen trenger 12 V og 0,4 A. M5StickS3 gir 3,3 V og noen få milliampere på en pinne. Derfor står et relé imellom: pinnen G5 styrer reléet, og reléet slår 12 V av og på. De to kretsene møtes bare i relékontakten, så 12 V kommer aldri inn på M5StickS3.

Koblingsskjema for låsekretsen: 12 V gjennom relékontaktene COM og NO til låsen, med dioden 1N4007 over låsen.
Forenklet tegning. Koblingsskjema for låsekretsen. Når G5 blir høy, trekker reléspolen, kontakten mellom COM og NO lukkes, og låsen får 12 V. Dioden står baklengs over låsen og leder bare i det øyeblikket strømmen brytes.

Låsen er en spole, og en spole lager en kort spenningstopp når strømmen brytes. Dioden 1N4007 gir toppen en vei rundt, slik at den ikke brenner relékontaktene. Hvorfor det virker, og hvordan du velger driver til større magneter, står i guiden om elektromagnet og solenoid. Grunnprinsippet for reléet finner du i guiden om relémodul med Arduino.

Koble relé og lås

Koblingstegning for relé og lås på M5StickS3: tre ledninger fra Hat2-kontakten til reléet og 12 V-kretsen via koblingsbrettet.
Forenklet tegning, sett ovenfra. Hat2-kontakten er tegnet forstørret, og navnene på pinnene står på etiketten på baksiden av M5StickS3. Låsekretsen på 12 V er tegnet i oransje og blått, og den har ingen ledning til M5StickS3.
  1. Trekk ut USB-kabelen og la strømforsyningen på 12 V ligge frakoblet mens du kobler.
  2. Reléet styres fra Hat2-kontakten, den doble raden med 16 hull i enden av M5StickS3. Bruk tre hann-hunn-ledninger: EXT_5V til + på reléet, GND til - og G5 (GPIO5) til S.
  3. Sett en hann-hunn-ledning fra en av VCC-pinnene på DC-modulen til skruterminalen COM på reléet. Stram skruen.
  4. Sett en hann-hann-ledning fra skruterminalen NO til kolonne 11 på koblingsbrettet. NC skal stå tom.
  5. Sett en hann-hunn-ledning fra en av GND-pinnene på DC-modulen til kolonne 3 på koblingsbrettet.
  6. Låsekabelen ender i en liten kontakt med to hull. Stikk en hann-hann-ledning i hvert hull: den fra rød leder går til kolonne 11, den fra svart leder til kolonne 3.
  7. Sett dioden mellom kolonne 3 og kolonne 11. Stripen på dioden skal peke mot kolonne 11, altså mot pluss.
  8. Se over alt en gang til mot tegningen. Koble så til USB, og til slutt 12 V.

På det lille koblingsbrettet henger de fem hullene i en kolonne sammen på hver side av midtsporet. Sett derfor alle ledningene og dioden på samme side av sporet. Da er kolonne 11 pluss og kolonne 3 minus for låsen.

Programmet for nivå 2

Programmet bygger på nivå 1. Nytt er reléet på G5, en hengelås på skjermen og en pause etter fem ukjente brikker på rad, slik at ingen kan stå og prøve seg fram.

// Nivå 2: M5StickS3 + M5Stack Unit RFID 2 + relémodul + elektromagnetisk lås på 12 V
// Kjente brikker og kort åpner låsen i noen sekunder. Fem ukjente på rad gir en pause.
// Biblioteker: M5Unified (0.3.0 eller nyere) og MFRC522_I2C (1.0).

#include <M5Unified.h>
#include <Wire.h>
#include <MFRC522_I2C.h>

MFRC522_I2C rfid(0x28, -1);  // I2C-adresse 0x28, ingen reset-pinne

const int PIN_RELE = 5;         // G5 på Hat2-kontakten, HIGH trekker reléet
const uint32_t APEN_MS = 3000;  // hvor lenge låsen holdes åpen
const uint8_t MAKS_FEIL = 5;    // så mange ukjente brikker på rad før pause
const uint32_t SPERRE_S = 30;   // pause i sekunder etter for mange feil

struct Bruker {
  const char* uid;   // UID med store bokstaver, uten mellomrom
  const char* navn;
};

// Bytt ut UID-ene med dine egne. Skjermen viser UID-en til en ukjent brikke.
const Bruker brukere[] = {
  { "04A1B2C3", "Kari" },
  { "53D4E5F6", "Bjørn" },
  { "A7B8C9D0", "Nora" },
};

uint8_t feilPaRad = 0;

String lesUid() {
  String uid;
  for (uint8_t i = 0; i < rfid.uid.size; i++) {
    if (rfid.uid.uidByte[i] < 0x10) uid += '0';
    uid += String(rfid.uid.uidByte[i], HEX);
  }
  uid.toUpperCase();
  return uid;
}

// Hengelås: bøylen står rett over kassen når den er låst, og løftet når den er åpen.
void tegnLas(int x, int y, bool apen, uint16_t farge, uint16_t bakgrunn) {
  auto& d = M5.Display;
  int loft = apen ? 12 : 0;
  d.fillArc(x, y - loft, 20, 14, 180, 360, farge);
  d.fillRect(x - 20, y - loft, 6, loft + 2, farge);
  d.fillRoundRect(x - 27, y, 54, 40, 6, farge);
  d.fillCircle(x, y + 16, 6, bakgrunn);
  d.fillRect(x - 2, y + 18, 4, 12, bakgrunn);
}

void visVent() {
  auto& d = M5.Display;
  d.fillScreen(TFT_BLACK);
  tegnLas(40, 52, false, TFT_WHITE, TFT_BLACK);
  d.setTextColor(TFT_WHITE);
  d.setTextDatum(middle_center);
  d.setFont(&fonts::efontJA_24_b);
  d.drawString("Hold brikken", 152, 48);
  d.drawString("mot leseren", 152, 86);
}

void visApen(const char* navn) {
  auto& d = M5.Display;
  uint16_t gronn = d.color565(0, 90, 40);
  d.fillScreen(gronn);
  tegnLas(40, 52, true, TFT_WHITE, gronn);
  d.setTextColor(TFT_WHITE);
  d.setTextDatum(middle_left);
  d.setFont(&fonts::efontJA_24_b);
  d.drawString("Hei,", 84, 30);
  d.drawString(String(navn) + "!", 84, 62);
  d.setFont(&fonts::efontJA_16);
  d.drawString("Låsen er åpen", 84, 104);
}

void visUkjent(const String& uid) {
  auto& d = M5.Display;
  d.fillScreen(d.color565(130, 0, 0));
  d.setTextColor(TFT_WHITE);
  d.setTextDatum(middle_center);
  d.setFont(&fonts::efontJA_24_b);
  d.drawString("Ukjent brikke", d.width() / 2, 34);
  d.setFont(&fonts::efontJA_16);
  d.drawString("UID: " + uid, d.width() / 2, 74);
  d.drawString("Forsøk " + String(feilPaRad) + " av " + String(MAKS_FEIL), d.width() / 2, 106);
}

void visSperre(uint32_t sekunder) {
  auto& d = M5.Display;
  d.fillScreen(TFT_BLACK);
  d.setTextColor(TFT_ORANGE);
  d.setTextDatum(middle_center);
  d.setFont(&fonts::efontJA_24_b);
  d.drawString("For mange forsøk", d.width() / 2, 44);
  d.drawString("Vent " + String(sekunder) + " s", d.width() / 2, 90);
}

void slippInn(const Bruker& b) {
  Serial.printf("%s: låsen er åpen i %lu s\n", b.navn, (unsigned long)(APEN_MS / 1000));
  feilPaRad = 0;
  visApen(b.navn);
  M5.Speaker.tone(1760, 120);
  digitalWrite(PIN_RELE, HIGH);  // reléet trekker, låsen får 12 V og bolten går inn
  delay(APEN_MS);
  digitalWrite(PIN_RELE, LOW);   // reléet slipper, fjæren skyver bolten ut igjen
  Serial.println("Låst igjen");
}

void avvis(const String& uid) {
  feilPaRad++;
  Serial.println("Ukjent brikke, UID: " + uid);
  visUkjent(uid);
  M5.Speaker.tone(220, 400);
  delay(2000);
  if (feilPaRad >= MAKS_FEIL) {
    Serial.printf("For mange forsøk, venter %lu s\n", (unsigned long)SPERRE_S);
    for (uint32_t s = SPERRE_S; s > 0; s--) {
      visSperre(s);
      delay(1000);
    }
    feilPaRad = 0;
  }
}

void setup() {
  pinMode(PIN_RELE, OUTPUT);
  digitalWrite(PIN_RELE, LOW);  // låst ved oppstart

  auto cfg = M5.config();
  cfg.output_power = true;  // 5 V ut på Grove-porten og EXT_5V
  M5.begin(cfg);
  M5.Power.setExtOutput(true);
  M5.Display.setRotation(1);  // liggende, 240 x 135 piksler
  M5.Speaker.setVolume(120);
  Serial.begin(115200);

  // Grove-porten på M5StickS3: SDA = G9 (gul), SCL = G10 (hvit)
  Wire.begin(M5.getPin(m5::pin_name_t::port_a_sda), M5.getPin(m5::pin_name_t::port_a_scl), 400000U);
  delay(100);
  rfid.PCD_Init();
  visVent();
}

void loop() {
  M5.update();

  if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) {
    delay(50);
    return;
  }

  String uid = lesUid();
  const Bruker* funnet = nullptr;
  for (const Bruker& b : brukere) {
    if (uid == b.uid) funnet = &b;
  }

  if (funnet) {
    slippInn(*funnet);
  } else {
    avvis(uid);
  }

  rfid.PICC_HaltA();  // be brikken være stille til den tas bort og holdes inntil på nytt
  visVent();
}

pinMode og digitalWrite(PIN_RELE, LOW) står aller først i setup(). Da er reléet sluppet før noe annet starter, og låsen går ikke opp av seg selv når M5StickS3 slås på. M5.Power.setExtOutput(true) slår på 5 V på EXT_5V, som reléspolen trenger.

Skjermbildene i nivå 2 på M5StickS3: låst hengelås, åpen lås med navn, ukjent brikke med teller og pause etter fem feil.
Slik skal skjermen se ut. Tallene er eksempler. Hengelåsen er lukket mens låsen venter og åpen i de tre sekundene bolten er inne. Etter fem ukjente brikker på rad teller skjermen ned fra 30 sekunder.
Kari: låsen er åpen i 3 s
Låst igjen
Ukjent brikke, UID: 9C41E27A

Test i riktig rekkefølge

  1. Bare USB, uten 12 V: hold en kjent brikke mot leseren. Reléet skal klikke én gang, og tre sekunder senere én gang til. Klikker det, virker styringen.
  2. Med 12 V: lysdioden på DC-modulen lyser. Bolten skal stå ute. Står den inne hele tiden, har du brukt NC i stedet for NO.
  3. Kjent brikke: bolten trekkes inn i tre sekunder og spretter ut igjen.
  4. Ukjent brikke: rød skjerm, dyp tone, og låsen rører seg ikke.
Reléet klikker ikke

Sjekk de tre ledningene i Hat2-kontakten mot etiketten på baksiden: EXT_5V, GND og G5. Sjekk også at M5.Power.setExtOutput(true) står i koden, og at M5StickS3 får strøm fra USB. Reléet trenger minst 3,3 V på S, og G5 gir akkurat 3,3 V. Det holder, men uten margin, så en løs ledning på S eller GND er nok til at reléet ikke trekker.

Reléet klikker, men bolten rører seg ikke

Da ligger feilen i 12 V-kretsen. Lyser lysdioden på DC-modulen? Sitter ledningene i COM og NO, og er skruene strammet? Står alle ledningene på samme side av midtsporet på koblingsbrettet?

M5StickS3 starter på nytt når låsen slipper

Det tyder på at dioden mangler eller står feil. Spenningstoppen fra spolen forstyrrer da elektronikken. Sjekk at stripen peker mot kolonne 11.

Test deg selv: hvorfor kobler vi låsen til NO og ikke NC?

NO er åpen når reléet er uten strøm. Da er låsen uten strøm og låst også hvis M5StickS3 mister strømmen eller programmet stopper. Med NC ville låsen stått åpen i nettopp de tilfellene.

Nivå 3: lås med ESP32, ESPHome og Home Assistant

Nivå 3: avansert. Tid: en ettermiddag. Du trenger ESP32-kortet, RC522-settet, OLED-skjermen, summermodulen, en LED med motstand fra LED-settet, to små koblingsbrett og hele låsekretsen fra nivå 2. Home Assistant må kjøre på nettverket ditt.

I nivå 2 ligger listen over brikker i programmet. Skal du gi en ny person adgang, må du laste opp på nytt. I nivå 3 flytter du listen til Home Assistant. ESP32 leser brikken og spør, og Home Assistant svarer «slipp inn» eller «avvis». Da kan du legge til og fjerne brikker fra mobilen, sette tidsregler, få varsel og se i loggen hvem som åpnet når.

Systemskisse for RFID-lås med ESPHome: ESP32 sender UID til Home Assistant og får svaret slipp inn eller avvis tilbake.
Forenklet tegning. ESP32 sender UID-en med tag_scanned. En automasjon i Home Assistant kaller handlingen slipp_inn eller avvis på ESP32. Er nettet nede, åpner bare nødbrikken, som ligger lagret på ESP32.

Fastvaren er ESPHome, et åpent prosjekt der du beskriver enheten i en YAML-fil i stedet for å programmere den. Komponentene for RC522, OLED-skjerm og tagger er velprøvde og vedlikeholdes av mange. Er Home Assistant nytt for deg, gir guiden om Home Assistant og protokoller oversikten.

ESP32 på to små koblingsbrett

ESP32-kortet med 30 pinner er bredt. På ett koblingsbrett dekker det nesten alle hullene, og du kommer ikke til pinnene på begge sider. Løsningen er to små brett med kortet som en bro imellom: den ene pinneraden i rad j på det øvre brettet, den andre i rad a på det nedre. Da får hver pinne fire ledige hull.

ESP32 med 30 pinner satt som en bro over to små koblingsbrett, slik at hver pinne har fire ledige hull ved siden av seg.
Forenklet tegning, sett ovenfra, med USB-kontakten til venstre. Raden med VIN står i rad j på det øvre brettet, raden med 3V3 i rad a på det nedre. Mellom brettene blir det en glipe på snaut 2 cm, og kortet bestemmer avstanden når du trykker det ned.

Navnene som er trykt på kortet, er D4, D5 og så videre. ESPHome bruker GPIO-numrene. Tallene er de samme: D5 er GPIO5, og TX2 er GPIO17. Trenger du en innføring i kortet, se ESP32 for nybegynnere.

Trinn 1: RC522 på 3,3 V

RC522 kommer med to løse pinnerader, en rett og en vinklet. Begge virker med hunn-hann-ledningene på koblingsbrettet. Skal leseren senere i veggboksen nederst i guiden, lodder du den vinklede raden på komponentsiden, med pinnene ut over kortkanten. Ellers tar du den rette. Har du ikke loddet før, hjelper guiden om loddeutstyr deg å velge. Leseren tåler bare 3,3 V. Kobler du den til 5 V eller VIN, går den i stykker.

Koblingstegning for RC522 til ESP32 med SPI: sju ledninger fra det nedre koblingsbrettet til pinnene på leseren.
Forenklet tegning, sett ovenfra. Alle sju ledningene går fra det nedre brettet, på samme side som 3V3. Pinnen IRQ på leseren brukes ikke.
RC522ESP32Ledning på tegningen
SDAD5 (GPIO5)Oransje
SCKD18 (GPIO18)Gul
MOSID23 (GPIO23)Blå
MISOD19 (GPIO19)Grønn
IRQIkke koblet
GNDGNDSvart
RSTD4 (GPIO4)Lilla
3.3V3V3Rød

Trinn 2: OLED-skjerm og summer

Koblingstegning for OLED-skjerm og summer til ESP32: I2C på D21 og D22, summeren på TX2, begge med strøm fra 3V3.
Forenklet tegning, sett ovenfra. Ledningene fra trinn 1 er ikke tegnet, men de skal bli stående. Skjermen bruker D21 (GPIO21) som SDA og D22 (GPIO22) som SCL. Summeren får signal fra TX2 (GPIO17).
ModulPinneESP32
OLEDGNDGND
OLEDVCC3V3
OLEDSCLD22 (GPIO22)
OLEDSDAD21 (GPIO21)
SummerVCC3V3
SummerI/OTX2 (GPIO17)
SummerGNDGND

Les merkingen på OLED-kortet før du kobler. Rekkefølgen på de fire pinnene varierer mellom produsenter, og VCC og GND kan ha byttet plass. Summeren er aktiv LOW: den piper når signalet er lavt. Derfor skal den ha strøm fra 3V3 og ikke fra 5 V. Med 5 V ville et signal på 3,3 V aldri blitt høyt nok til å stoppe lyden.

Trinn 3: relé og grønn LED

Koblingstegning for relé og grønn LED til ESP32: VIN, GND og D26 til relémodulen, D25 til LED-en gjennom en motstand.
Forenklet tegning, sett ovenfra. Reléet får 5 V fra VIN, som er USB-spenningen. Motstanden på 1 kΩ går over midtsporet fra kolonnen til D25, LED-en står med det lange beinet mot motstanden, og en kort ledning tar det korte beinet til GND.

Flytt de tre ledningene fra reléet: + går til VIN, - til GND og S til D26 (GPIO26). Motstanden går fra D25 (GPIO25) over midtsporet til den øvre halvdelen av brettet, og LED-en kobles videre derfra til GND. COM og NO på reléet er koblet til låsekretsen akkurat som i nivå 2, og den rører du ikke.

ESPHome-konfigurasjonen

Installer tillegget ESPHome Device Builder i Home Assistant, lag en ny enhet og lim inn denne filen. Tillegg finnes i Home Assistant OS. Kjører du Home Assistant i Docker, starter du ESPHome Device Builder som en egen container. Den er kompilert med ESPHome 2026.10. Les mer om komponenten i ESPHome-dokumentasjonen for RC522.

# Nivå 3: RFID-lås med ESPHome og Home Assistant
# ESP32 (30 pinner) + RC522 (SPI) + OLED 0,96" SSD1306 (I2C) + relémodul + lås 12 V + summer og LED
# Kompilert med ESPHome 2026.10.

substitutions:
  apen_tid: 3s
  # Nødbrikke som åpner når Home Assistant ikke svarer. Bytt ut med din egen UID.
  nodbrikke: 74-10-37-94

esphome:
  name: rfid-las
  friendly_name: RFID-lås

esp32:
  board: esp32dev
  framework:
    type: esp-idf

logger:

api:
  encryption:
    key: !secret api_key
  # Uten Home Assistant skal låsen virke med nødbrikken, ikke starte på nytt hvert kvarter.
  reboot_timeout: 0s
  actions:
    # Home Assistant kaller denne når en kjent brikke er lest og betingelsene er oppfylt.
    - action: slipp_inn
      variables:
        navn: string
      then:
        - script.stop: vent_svar
        - lambda: |-
            id(linje1) = "Hei,";
            id(linje2) = navn;
        - script.execute: apne_las
    - action: avvis
      variables:
        grunn: string
      then:
        - script.stop: vent_svar
        - lambda: |-
            id(linje1) = "Ingen adgang";
            id(linje2) = grunn;
        - script.execute: pip_feil
        - script.execute: rydd_skjerm

ota:
  - platform: esphome
    password: !secret ota_password

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password
  ap:
    ssid: "RFID-las oppsett"
    password: !secret ap_password

captive_portal:

globals:
  - id: linje1
    type: std::string
    initial_value: '"Hold brikken"'
  - id: linje2
    type: std::string
    initial_value: '"mot leseren"'

spi:
  clk_pin: GPIO18
  miso_pin: GPIO19
  mosi_pin: GPIO23

rc522_spi:
  cs_pin: GPIO5
  reset_pin: GPIO4
  update_interval: 500ms
  on_tag:
    then:
      - if:
          condition:
            api.connected:
          then:
            # Home Assistant bestemmer. Kommer det ikke svar, viser skjermen "Ingen adgang".
            - homeassistant.tag_scanned: !lambda 'return x;'
            - lambda: |-
                id(linje1) = "Sjekker";
                id(linje2) = "brikken";
            - script.execute: vent_svar
          else:
            - if:
                condition:
                  lambda: 'return x == "${nodbrikke}";'
                then:
                  - lambda: |-
                      id(linje1) = "Nødbrikke";
                      id(linje2) = "uten nett";
                  - script.execute: apne_las
                else:
                  - lambda: |-
                      id(linje1) = "Ingen adgang";
                      id(linje2) = "uten nett";
                  - script.execute: pip_feil
                  - script.execute: rydd_skjerm

script:
  - id: vent_svar
    mode: restart
    then:
      - delay: 2s
      - lambda: |-
          id(linje1) = "Ingen adgang";
          id(linje2) = "ukjent brikke";
      - script.execute: pip_feil
      - script.execute: rydd_skjerm
  - id: apne_las
    mode: restart
    then:
      - switch.turn_on: las
      - output.turn_on: gronn_led
      - output.turn_on: summer
      - delay: 120ms
      - output.turn_off: summer
      - delay: ${apen_tid}
      - switch.turn_off: las
      - output.turn_off: gronn_led
      - script.execute: rydd_skjerm
  - id: pip_feil
    mode: restart
    then:
      - repeat:
          count: 3
          then:
            - output.turn_on: summer
            - delay: 80ms
            - output.turn_off: summer
            - delay: 80ms
  - id: rydd_skjerm
    mode: restart
    then:
      - delay: 3s
      - lambda: |-
          id(linje1) = "Hold brikken";
          id(linje2) = "mot leseren";

switch:
  - platform: gpio
    id: las
    name: "Lås"
    # Bare skriptet apne_las styrer reléet. Ingen bryter i Home Assistant kan åpne låsen.
    internal: true
    pin: GPIO26
    restore_mode: ALWAYS_OFF

output:
  # Aktiv summermodul: LOW gir lyd, derfor inverted.
  - platform: gpio
    id: summer
    pin:
      number: GPIO17
      inverted: true
  - platform: gpio
    id: gronn_led
    pin: GPIO25

i2c:
  sda: GPIO21
  scl: GPIO22

font:
  - file: "gfonts://Roboto@500"
    id: skrift
    size: 16
    glyphs: " !,.:-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZÆØÅabcdefghijklmnopqrstuvwxyzæøå"

display:
  - platform: ssd1306_i2c
    model: "SSD1306 128x64"
    address: 0x3C
    update_interval: 500ms
    lambda: |-
      if (id(las).state) {
        it.filled_rectangle(0, 0, 128, 4);
      }
      it.print(64, 22, id(skrift), TextAlign::CENTER, id(linje1).c_str());
      it.print(64, 46, id(skrift), TextAlign::CENTER, id(linje2).c_str());

Passordene ligger i secrets.yaml, slik at du kan dele konfigurasjonen uten å dele dem:

# Kopier til secrets.yaml og fyll inn egne verdier.
wifi_ssid: "NettverketDitt"
wifi_password: "wifi-passordet"
ap_password: "minst-8-tegn"
ota_password: "velg-et-passord"
# Lag nøkkelen på esphome.io/components/api (feltet under "encryption") eller la ESPHome-veiviseren lage den.
api_key: "LIM-INN-32-BYTE-BASE64-NOKKEL-HER="

Første gang må ESP32 kobles til datamaskinen med USB. Velg Install og Plug into this computer i Chrome eller Edge. Det virker bare når Home Assistant er åpnet over HTTPS. Åpner du den med http://, velger du Manual download og laster filen inn på ESP32 fra web.esphome.io. Senere oppdateringer går trådløst. Når enheten er på nett, dukker den opp under Innstillinger > Enheter og tjenester i Home Assistant. Legg den til, og lim inn API-nøkkelen når du blir spurt.

Slik leser du konfigurasjonen

  • rc522_spi leser brikker to ganger i sekundet. on_tag kjører hver gang en brikke kommer inn i feltet, med UID-en i variabelen x.
  • homeassistant.tag_scanned sender UID-en til Home Assistant. Skjermen viser «Sjekker brikken», og skriptet vent_svar gir Home Assistant to sekunder på å svare.
  • api: actions: lager to handlinger som Home Assistant kan kalle: slipp_inn med et navn og avvis med en grunn. Begge stopper ventingen.
  • apne_las slår på reléet og den grønne LED-en, gir et kort pip, venter apen_tid og låser igjen.
  • restore_mode: ALWAYS_OFF sørger for at låsen er låst etter omstart og strømbrudd. internal: true holder reléet utenfor Home Assistant. Da kan verken en bryter i panelet eller en talekommando åpne låsen og la den stå åpen. Bare handlingen slipp_inn åpner, og den låser igjen etter apen_tid.
  • Uten kontakt med Home Assistant åpner bare brikken i nodbrikke. Bytt den ut med UID-en til en brikke du oppbevarer et trygt sted. reboot_timeout: 0s hindrer at ESP32 starter på nytt hvert kvarter mens Home Assistant er borte.

Registrer brikker og lag regler i Home Assistant

  1. Hold en brikke mot leseren. Skjermen viser «Sjekker brikken» og så «Ingen adgang, ukjent brikke», fordi det ikke finnes noen regel ennå.
  2. Åpne Innstillinger > Tagger i Home Assistant. Home Assistant kaller brikkene «tagger». Brikken står i listen med UID-en som fire tallpar, for eksempel 53-A1-B2-C3. Gi den et navn.
  3. Lag en automasjon som utløses av taggen og kaller handlingen esphome.rfid_las_slipp_inn med navnet som skal stå på skjermen.

Her er to automasjoner du kan lime inn og tilpasse. Den første slipper inn Kari mellom klokken 06 og 23. Den andre slipper inn Bjørn på hverdager i arbeidstiden. Utenfor tiden avviser begge, med beskjed på skjermen. Filen har samme format som automations.yaml. I redigeringsprogrammet i Home Assistant limer du inn én automasjon om gangen, uten bindestreken foran alias.

# Home Assistant: én automasjon per person, i samme format som filen automations.yaml.
# I redigeringsprogrammet (Innstillinger > Automasjoner > Ny > Rediger i YAML) limer du inn
# én automasjon om gangen, uten bindestreken foran alias.
# tag_id er UID-en slik den står under Innstillinger > Tagger. Har du flere lesere,
# legger du til device_id under trigger, slik at bare denne leseren åpner låsen.

- alias: "RFID-lås: slipp inn Kari"
  triggers:
    - trigger: tag
      tag_id: 53-A1-B2-C3
  actions:
    - choose:
        - conditions:
            - condition: time
              after: "06:00:00"
              before: "23:00:00"
          sequence:
            - action: esphome.rfid_las_slipp_inn
              data:
                navn: Kari
      default:
        - action: esphome.rfid_las_avvis
          data:
            grunn: ikke nå

- alias: "RFID-lås: Bjørn bare på hverdager"
  triggers:
    - trigger: tag
      tag_id: 04-D5-E6-F7
  actions:
    - choose:
        - conditions:
            - condition: time
              weekday: [mon, tue, wed, thu, fri]
              after: "07:00:00"
              before: "17:00:00"
          sequence:
            - action: esphome.rfid_las_slipp_inn
              data:
                navn: Bjørn
      default:
        - action: esphome.rfid_las_avvis
          data:
            grunn: ikke nå

Alt som skjer, havner i loggboken i Home Assistant. Vil du ha varsel på mobilen når en ukjent brikke prøves, lager du en automasjon som utløses av hendelsen tag_scanned og sender et varsel.

Skjermbildene på OLED-skjermen i nivå 3: venter, sjekker brikken, slipper inn Kari, ukjent brikke, feil tidspunkt og nødbrikke.
Slik skal skjermen se ut. Navnet er et eksempel. Streken øverst vises mens reléet er trukket og låsen er åpen. De to tekstlinjene kommer fra konfigurasjonen og fra automasjonene i Home Assistant.

Variant uten Home Assistant

Vil du ha samme maskinvare uten Home Assistant, kan du laste opp dette programmet fra Arduino IDE i stedet. Koblingen er den samme, og listen over brikker ligger i programmet som i nivå 2. Velg kortet «DOIT ESP32 DEVKIT V1» og installer bibliotekene MFRC522 (1.4.12) og U8g2.

// Nivå 3, frittstående variant: ESP32 + RC522 (SPI) + OLED SSD1306 (I2C) + relé + lås på 12 V
// Samme kobling som ESPHome-varianten, men uten Home Assistant: brikkelisten ligger i programmet.
// Biblioteker: MFRC522 av GithubCommunity (1.4.12) og U8g2 av oliver.

#include <SPI.h>
#include <Wire.h>
#include <MFRC522.h>
#include <U8g2lib.h>

const uint8_t PIN_SS = 5;       // RC522 SDA
const uint8_t PIN_RST = 4;      // RC522 RST
const uint8_t PIN_RELE = 26;    // relémodul S, HIGH trekker reléet
const uint8_t PIN_LED = 25;     // grønn LED via 1 kΩ
const uint8_t PIN_SUMMER = 17;  // aktiv summermodul på TX2, LOW gir lyd

const uint32_t APEN_MS = 3000;  // hvor lenge låsen holdes åpen
const uint8_t MAKS_FEIL = 5;    // så mange ukjente brikker på rad før pause
const uint32_t SPERRE_S = 30;   // pause i sekunder etter for mange feil

struct Brikke {
  const char* uid;   // UID med store bokstaver, uten mellomrom
  const char* navn;
};

// Bytt ut UID-ene med dine egne. Serial Monitor viser UID-en til en ukjent brikke.
const Brikke tillatt[] = {
  { "53A1B2C3", "Kari" },
  { "04D5E6F7", "Bjørn" },
};

MFRC522 rfid(PIN_SS, PIN_RST);
U8G2_SSD1306_128X64_NONAME_F_HW_I2C oled(U8G2_R0, U8X8_PIN_NONE);  // SDA = D21, SCL = D22
uint8_t feilPaRad = 0;

// To midtstilte linjer. Skriften u8g2_font_helvB12_te har æ, ø og å.
void vis(const String& linje1, const String& linje2) {
  oled.clearBuffer();
  oled.setFont(u8g2_font_helvB12_te);
  oled.drawUTF8((128 - oled.getUTF8Width(linje1.c_str())) / 2, 26, linje1.c_str());
  oled.drawUTF8((128 - oled.getUTF8Width(linje2.c_str())) / 2, 52, linje2.c_str());
  oled.sendBuffer();
}

void visVent() {
  vis("Hold brikken", "mot leseren");
}

void pip(uint16_t ms) {
  digitalWrite(PIN_SUMMER, LOW);
  delay(ms);
  digitalWrite(PIN_SUMMER, HIGH);
}

String lesUid() {
  String uid;
  for (uint8_t i = 0; i < rfid.uid.size; i++) {
    if (rfid.uid.uidByte[i] < 0x10) uid += '0';
    uid += String(rfid.uid.uidByte[i], HEX);
  }
  uid.toUpperCase();
  return uid;
}

void slippInn(const char* navn) {
  Serial.printf("%s: låsen er åpen i %lu s\n", navn, (unsigned long)(APEN_MS / 1000));
  feilPaRad = 0;
  vis(String("Hei, ") + navn, "Låsen er åpen");
  digitalWrite(PIN_LED, HIGH);
  digitalWrite(PIN_RELE, HIGH);
  pip(120);
  delay(APEN_MS);
  digitalWrite(PIN_RELE, LOW);
  digitalWrite(PIN_LED, LOW);
  Serial.println("Låst igjen");
}

void avvis(const String& uid) {
  feilPaRad++;
  Serial.println("Ukjent brikke, UID: " + uid);
  vis("Ukjent brikke", "Forsøk " + String(feilPaRad) + " av " + String(MAKS_FEIL));
  for (uint8_t i = 0; i < 3; i++) {
    digitalWrite(PIN_LED, HIGH);
    pip(80);
    digitalWrite(PIN_LED, LOW);
    delay(80);
  }
  delay(1500);
  if (feilPaRad >= MAKS_FEIL) {
    Serial.printf("For mange forsøk, venter %lu s\n", (unsigned long)SPERRE_S);
    for (uint32_t s = SPERRE_S; s > 0; s--) {
      vis("Sperret", "Vent " + String(s) + " s");
      delay(1000);
    }
    feilPaRad = 0;
  }
}

void setup() {
  pinMode(PIN_SUMMER, OUTPUT);
  digitalWrite(PIN_SUMMER, HIGH);  // HIGH = stille
  pinMode(PIN_RELE, OUTPUT);
  digitalWrite(PIN_RELE, LOW);     // låst ved oppstart
  pinMode(PIN_LED, OUTPUT);

  Serial.begin(115200);
  oled.begin();                    // I2C på D21 (SDA) og D22 (SCL)
  SPI.begin();                     // SCK = D18, MISO = D19, MOSI = D23
  rfid.PCD_Init();
  delay(50);
  rfid.PCD_DumpVersionToSerial();  // 0x00 eller 0xFF: sjekk ledningene
  Serial.println("Klar. Hold en brikke mot leseren.");
  visVent();
}

void loop() {
  if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) {
    delay(50);
    return;
  }

  String uid = lesUid();
  const Brikke* funnet = nullptr;
  for (const Brikke& k : tillatt) {
    if (uid == k.uid) funnet = &k;
  }

  if (funnet) {
    slippInn(funnet->navn);
  } else {
    avvis(uid);
  }

  rfid.PICC_HaltA();
  rfid.PCD_StopCrypto1();
  visVent();
}
Firmware Version: 0x92 = v2.0
Klar. Hold en brikke mot leseren.
Ukjent brikke, UID: 9C41E27A
Kari: låsen er åpen i 3 s
Låst igjen

Første linje kommer fra PCD_DumpVersionToSerial(). Tallet 0x91 eller 0x92 betyr at ESP32 snakker med RC522. Mange rimelige moduler svarer 0x88, 0x12 eller «unknown», og de virker også. Står det 0x00 eller 0xFF, er minst én av de sju ledningene koblet feil.

Hvis det ikke virker

ESPHome-loggen viser ingen brikker

Sjekk ledningene mot tabellen i trinn 1, og særlig SDA på D5 og RST på D4. Sjekk også loddingen på pinneraden: en kaldlodding gir kontakt bare av og til. Rekkevidden på RC522 er et par centimeter, og metall bak leseren demper feltet.

OLED-skjermen er svart

Se etter i ESPHome-loggen om I2C-skanningen finner en enhet på 0x3C. Finner den 0x3D, bytter du adressen i konfigurasjonen. Finner den ingenting, har SDA og SCL byttet plass, eller VCC og GND står motsatt av det du trodde.

Summeren piper hele tiden

Da får den strøm fra 5 V, eller signalet er koblet til feil pinne. Flytt VCC til 3V3 og signalet til TX2.

Skjermen viser «Ingen adgang, ukjent brikke» for en brikke du har lagt inn

Sammenlign tag_id i automasjonen med UID-en under Tagger, tegn for tegn og med bindestreker. Sjekk også at automasjonen er slått på. Utenfor tiden i automasjonen viser skjermen «ikke nå».

Test deg selv: hva skjer hvis Wi-Fi faller ut?

Etter kort tid merker ESP32 at kontakten med Home Assistant er borte. Da sender den ikke UID-en, men sammenligner den med nødbrikken. Bare den åpner. Alle andre får «Ingen adgang, uten nett». Har du loggen til ESPHome åpen i nettleseren mens Home Assistant er nede, regnes det som kontakt, og da åpner heller ikke nødbrikken.

Brikke, kort eller klistremerke?

Alle tre nivåene leser MIFARE-brikker på 13,56 MHz, og du kan blande former fritt. Programmet ser bare UID-en. Gi gjerne hver person én brikke på nøkkelknippet og ett kort i lommeboken, og legg inn begge UID-ene med samme navn.

FormProduktPasser til
NøkkelbrikkeNøkkelbrikker, 10 stkNøkkelknippet. Tåler støt og lommer.
KortRFID-kort, 10 stk eller NFC-kort, 10 stkLommebok og kortholder. Størst antenne og best rekkevidde.
KlistremerkeMIFARE Classic-klistremerkeEn gjenstand du alltid har med deg, for eksempel et etui. Ikke rett på metall.
Rund brikkeHvit brikke, 25 mmInnfelt i noe du lager selv, for eksempel en 3D-printet nøkkelring.
Rund NFC-brikkeGjennomsiktig NTAG203, 25 mmNår mobilen også skal kunne lese brikken. UID-en har sju byte.

NTAG-brikker har UID på sju byte, altså fjorten tegn i listen i stedet for åtte. Programmene her takler begge lengder. Brikker på 125 kHz virker ikke med disse leserne, selv om de ser like ut.

Montering: leseren ute, resten inne

Plassering av leser, styring og lås sett ovenfra: bare leseren på utsiden, mens relé, strømforsyning og lås står på innsiden.
Forenklet tegning, sett ovenfra og ikke i målestokk. Den som står utenfor, skal bare komme til leseren. Står reléet ute, kan låsen åpnes ved å koble to ledninger sammen.

Regelen er enkel: bare leseren skal være tilgjengelig fra utsiden. Relé, strømforsyning og ESP32 står inne i skapet eller på innsiden av døren. RC522 leser gjennom et par millimeter plast eller tre, men ikke gjennom metall. Mellom leseren og ESP32 går sju ledere. Hold kabelen kort, helst under en halv meter: SPI er laget for korte avstander, og lange ledninger gir lesefeil. Sett derfor ESP32 rett bak veggen der leseren sitter, og la heller kabelen til låsen være lang.

Fotorealistisk illustrasjon av den elektriske låsen skrudd fast på innsiden av en skapdør i kryssfiner, med sluttstykke på skapsiden.
Illustrasjon. Låsen sitter på innsiden av døren, og fallen går inn i sluttstykket på skapsiden når døren lukkes. Ledningene festes langs døren og går over til skapet på hengselsiden, der de bøyes minst.

Låsen skrus fast på innsiden, slik at bolten går inn i en kant eller et sluttstykke når døren er lukket. Den skrå siden av bolten skal vende mot kanten. Da kan døren smekkes igjen uten strøm, akkurat som en vanlig smekklås.

Vil du ha leseren pent på veggen, finnes det en slank 3D-printet veggboks som er tilpasset RC522-modulen. Kortet leses gjennom fronten, og en ring i fronten viser hvor du holder det. Boksen henger på to skruer med 85 mm avstand, og kabelen går ut bak eller nederst. Den har plass til den vinklede pinneraden og en grønn lysdiode i fronten. Bruker du lysdioden der, går den samme ledningen fra D25 gjennom 1 kΩ-motstanden ut til boksen, og katoden kobles til GND-ledningen inne i boksen. Boksen er ikke tett, så den skal sitte inne eller under tak.

Hvor sikker er en RFID-lås du bygger selv?

UID kan kopieres

Alle lesere kan hente UID-en, og den kan skrives til en brikke der UID-en kan skrives om. En lås som bare sjekker UID, stopper derfor ikke en som har lånt brikken din i et minutt.

Pausen hjelper mot gjetting

Fem feil gir 30 sekunders pause. Med over fire milliarder mulige UID-er på fire byte er gjetting da i praksis umulig.

Mekanikken er svakest

Bolten er noen millimeter stål i et lite hus. Den tåler ikke et brekkjern. Det samme gjelder de fleste skapdører.

Vil du ha noe sikrere, er neste steg brikker med kryptering, som MIFARE DESFire, og en leser som kan snakke med dem, for eksempel PN532. Forskjellen mellom brikketypene er forklart i guiden om RFID og NFC. En kraftigere lås for dører er en dørmagnet på 12 V, men den virker motsatt vei: den holder døren mens den har strøm, og slipper når strømmen går. Da kobler du den til NC i stedet for NO, slik at reléet bryter strømmen i de sekundene døren skal åpnes.

Vanlige spørsmål

Kan jeg bruke Arduino UNO i stedet for ESP32?

RC522 er en 3,3 V-leser, og UNO har 5 V på signalpinnene. Da trenger du nivåomformer på SPI-linjene. Med ESP32 slipper du det, og du får Wi-Fi med på kjøpet. Varianten uten Home Assistant i nivå 3 er et vanlig Arduino-program og kan tilpasses andre kort.

Kan mobilen brukes som nøkkel?

Ikke direkte. En mobil som later som den er et kort, sender en ny tilfeldig UID hver gang, nettopp for at den ikke skal kunne spores. Et klistremerke på baksiden av dekselet har en fast UID og virker som en brikke. Noen mobiler reagerer da på merket selv, og metall eller magneter i dekselet demper det.

Hvor langt unna kan brikken leses?

Unit RFID 2 leser på under 20 mm. RC522 leser kort på opptil rundt 5 cm, og nøkkelbrikker må nærmere fordi antennen i dem er mindre. Det er en fordel: ingen åpner låsen ved å gå forbi.

Hva skjer når strømmen går?

Låsen forblir låst, fordi bolten bare trekkes inn mens den får 12 V. Tenk derfor gjennom hvordan du kommer inn i skapet hvis strømforsyningen ryker. En skjult nødåpning eller en skrue du kommer til fra utsiden, kan være lurt.

Kan alt gå på batteri?

M5StickS3 har batteri, men låsen trekker 0,4 A ved 12 V hver gang den åpner, og det klarer ikke det lille batteriet. Bruk strømforsyning til låsen. Skal alt være trådløst, trenger du en 12 V-batteripakke og en step-down-omformer til 5 V.

Er det lov å kopiere en adgangsbrikke?

Dine egne brikker til ditt eget skap kan du gjøre hva du vil med. Brikker til arbeidsplass, borettslag eller treningssenter tilhører systemeieren, og kopiering uten avtale kan være brudd på både avtalen og loven.

Hvor går du videre?

Alle guider

Produkter omtalt i denne guiden

Produktene som brukes og sammenlignes i guiden, med pris og lagerstatus.