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.
- 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
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 ettM5StickS3, kompakt IoT-utviklingsmodul med ESP32-S3, WiFi og 1,14" skjermPå lagerkr 489,00
M5Stack Unit RFID 2, MR-015201 stk, nivå 1 og 2: leser på 13,56 MHz med Grove-kabel i eskenRFID-modul for lesing og skriving med I2C, 13,56 MHzPå lagerkr 275,00
Nøkkelbrikker 13,56 MHz, 10 stk, MR-00981Alle nivåer: én brikke per personRFID NFC-nøkkelbrikke 13,56 MHz Mifare, unik 32-bit ID, 10 stk.På lagerkr 189,00
RFID-kort 13,56 MHz, 10 stk, MR-00983Alle nivåer: kort i bankkortstørrelseRFID identifikasjonskort 13,56 MHz, MIFARE, 10 stkPå lagerkr 269,00
Relémodul 1 kanal 5 V, MR-016281 stk, nivå 2 og 3: bryteren som slipper 12 V til låsenRelémodul med 1 kanal, 5V spole og 10A/250V AC-kontakterPå lagerkr 79,00
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ømElektromagnetisk lås med innfellbar låsebolt, 12VPå lagerkr 299,00- Strømforsyning 12 V 2,5 A, MR-007641 stk, nivå 2 og 3: strøm til låsenStrømforsyning 12V 2,5A 30W med DC 5,5/2,1mm pluggPå lagerkr 239,00
DC-modul med 5,5 × 2,1 mm-kontakt, MR-012881 stk, nivå 2 og 3: gjør pluggen fra strømforsyningen om til pinnerModul med DC-kontakt 5,5 x 2,1 mm og LEDPå lagerkr 79,00
Diode 1N4007, 10 stk, MR-017811 stk, nivå 2 og 3: friløpsdiode over låsenLikeretterdiode 1N4007, 1A/1000V, 10-pakningPå lagerkr 25,00
Lite koblingsbrett, 170 hull, MR-012781 stk i nivå 2, 3 stk i nivå 3Loddefritt koblingsbrett med 170 kontaktpunkter, hvittPå lagerkr 49,00
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 reserveKoblingskabler 20 cm - M/M, F/F, M/F - Sett med 120 stk.På lagerkr 169,00- ESP32-utviklingskort med 30 pinner, MR-015641 stk, nivå 3ESP32-utviklingskort med WiFi og Bluetooth 4.2På lagerkr 369,00
RC522-sett med kort og nøkkelbrikke, MR-005411 stk, nivå 3: leseren, pinnerad som må loddes, ett kort og én brikkeRFID-modul 13,56 MHz med SPI-grensesnitt og NFC-brikkerPå lagerkr 139,00- OLED-skjerm 0,96" I2C, MR-016361 stk, nivå 3: viser hva låsen gjørOLED-skjerm 0,96 tommer med blå visning, I2C og 128 x 64 pikslerPå lagerkr 165,00
- Aktiv summermodul, MR-009501 stk, nivå 3: lydsignalAktiv buzzer-modul med generator, 3,3-5,5 V, LOW-styringPå lagerkr 95,00
LED-sett med 1 kΩ-motstander, MR-014501 grønn LED og 1 motstand, nivå 3LED-sett med 160 lysdioder, 200 motstander og sortimentsboksPå lagerkr 179,00
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
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.
Koble til og gjør klar Arduino IDE
- 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.
- Koble M5StickS3 til PC-en med USB-C.
- 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.
- Åpne Library Manager og installer
M5Unified(0.3.0 eller nyere) ogMFRC522_I2C. - 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.
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
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.
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
- Trekk ut USB-kabelen og la strømforsyningen på 12 V ligge frakoblet mens du kobler.
- 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.
- Sett en hann-hunn-ledning fra en av VCC-pinnene på DC-modulen til skruterminalen COM på reléet. Stram skruen.
- Sett en hann-hann-ledning fra skruterminalen NO til kolonne 11 på koblingsbrettet. NC skal stå tom.
- Sett en hann-hunn-ledning fra en av GND-pinnene på DC-modulen til kolonne 3 på koblingsbrettet.
- 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.
- Sett dioden mellom kolonne 3 og kolonne 11. Stripen på dioden skal peke mot kolonne 11, altså mot pluss.
- 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.
Kari: låsen er åpen i 3 s Låst igjen Ukjent brikke, UID: 9C41E27A
Test i riktig rekkefølge
- 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.
- 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.
- Kjent brikke: bolten trekkes inn i tre sekunder og spretter ut igjen.
- 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
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.
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.
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.
| RC522 | ESP32 | Ledning på tegningen |
|---|---|---|
| SDA | D5 (GPIO5) | Oransje |
| SCK | D18 (GPIO18) | Gul |
| MOSI | D23 (GPIO23) | Blå |
| MISO | D19 (GPIO19) | Grønn |
| IRQ | Ikke koblet | |
| GND | GND | Svart |
| RST | D4 (GPIO4) | Lilla |
| 3.3V | 3V3 | Rød |
Trinn 2: OLED-skjerm og summer
| Modul | Pinne | ESP32 |
|---|---|---|
| OLED | GND | GND |
| OLED | VCC | 3V3 |
| OLED | SCL | D22 (GPIO22) |
| OLED | SDA | D21 (GPIO21) |
| Summer | VCC | 3V3 |
| Summer | I/O | TX2 (GPIO17) |
| Summer | GND | GND |
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
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_spileser brikker to ganger i sekundet.on_tagkjører hver gang en brikke kommer inn i feltet, med UID-en i variabelenx.homeassistant.tag_scannedsender UID-en til Home Assistant. Skjermen viser «Sjekker brikken», og skriptetvent_svargir Home Assistant to sekunder på å svare.api: actions:lager to handlinger som Home Assistant kan kalle:slipp_innmed et navn ogavvismed en grunn. Begge stopper ventingen.apne_lasslår på reléet og den grønne LED-en, gir et kort pip, venterapen_tidog låser igjen.restore_mode: ALWAYS_OFFsørger for at låsen er låst etter omstart og strømbrudd.internal: trueholder reléet utenfor Home Assistant. Da kan verken en bryter i panelet eller en talekommando åpne låsen og la den stå åpen. Bare handlingenslipp_innåpner, og den låser igjen etterapen_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: 0shindrer at ESP32 starter på nytt hvert kvarter mens Home Assistant er borte.
Registrer brikker og lag regler i Home Assistant
- Hold en brikke mot leseren. Skjermen viser «Sjekker brikken» og så «Ingen adgang, ukjent brikke», fordi det ikke finnes noen regel ennå.
- Å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. - Lag en automasjon som utløses av taggen og kaller handlingen
esphome.rfid_las_slipp_innmed 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.
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.
| Form | Produkt | Passer til |
|---|---|---|
| Nøkkelbrikke | Nøkkelbrikker, 10 stk | Nøkkelknippet. Tåler støt og lommer. |
| Kort | RFID-kort, 10 stk eller NFC-kort, 10 stk | Lommebok og kortholder. Størst antenne og best rekkevidde. |
| Klistremerke | MIFARE Classic-klistremerke | En gjenstand du alltid har med deg, for eksempel et etui. Ikke rett på metall. |
| Rund brikke | Hvit brikke, 25 mm | Innfelt i noe du lager selv, for eksempel en 3D-printet nøkkelring. |
| Rund NFC-brikke | Gjennomsiktig NTAG203, 25 mm | Nå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
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.

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?
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.
Fem feil gir 30 sekunders pause. Med over fire milliarder mulige UID-er på fire byte er gjetting da i praksis umulig.
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?
- RFID og NFC forklart: frekvenser, brikketyper, minne og alle leserne i butikken.
- Relémodul med Arduino: COM, NO og NC grundig, med tre prosjekter på 5 V.
- UIFlow 2 og MicroPython på M5Stack: lag nivå 1 med blokker i stedet for C++.
- Home Assistant og protokoller: bygg ut med sensorer og varsler.




