Własny czytnik NFC w projekcie z Arduino lub Raspberry Pi – od anteny i magistrali do zamka na przekaźniku

Karta, którą przykładasz do drzwi biura, i naklejka, którą telefon rozpoznaje na plakacie, korzystają z tego samego zjawiska. Pole magnetyczne o częstotliwości 13,56 MHz zasila bierny układ w karcie i jednocześnie przenosi dane na odległość kilku centymetrów. To jest właśnie NFC (Near Field Communication). Dla majsterkowicza oznacza to coś bardzo praktycznego. Gotowy moduł za kilkanaście złotych, płytka Arduino albo Raspberry Pi i kilkanaście linii kodu wystarczą, żeby odczytać numer UID (Unique Identifier) własnego tagu i na tej podstawie włączyć przekaźnik, oświetlenie albo elektrozaczep.

Ten tekst jest przewodnikiem po takiej budowie, a nie katalogiem gotowych obudów. Najpierw rozdzielimy NFC od starszych pastylek zbliżeniowych 125 kHz, potem porównamy układy PN532 i RC522, opiszemy magistrale SPI, I2C oraz UART, pokażemy odczyt identyfikatora w C++ i w Pythonie, a na końcu złożymy prosty zamek. Po drodze będzie też o metalu, który psuje antenę, i o tym, czego nie należy obiecywać sobie po samym numerze karty.

Od karty zbliżeniowej do własnego zamka – co naprawdę budujesz

Zanim kupisz moduł, warto nazwać zadanie. Czytnik w autorskim projekcie nie jest magicznym zamkiem z marketu. Jest radiem krótkiego zasięgu, które co chwilę pyta, czy w polu anteny pojawił się bierny układ, a potem przekazuje jego identyfikator do programu. Program porównuje ten identyfikator z listą uprawnionych i dopiero wtedy steruje pinem. Pin może zapalić diodę, wysłać komunikat do automatyki biurowej albo na kilka sekund zwolnić elektrozaczep. Cała „inteligencja” siedzi w Twoim kodzie, nie w naklejce.

Do pierwszych prób wystarczy niewiele. Potrzebny jest moduł czytnika z wlutowaną anteną, płytka z mikrokontrolerem albo Raspberry Pi, kilka przewodów, zasilanie 3,3 V o sensownej wydajności prądowej oraz jeden własny tag. Dobrze nadają się karty i breloki MIFARE Classic, a także nalepki NTAG213. Nie nadają się popularne pastylki i breloki 125 kHz, mimo że sprzedawcy też nazywają je RFID. RC522 i PN532 ich nie zobaczą, bo nasłuchują innego pasma i innego protokołu, chiefly ISO/IEC 14443 typu A.

Warto od razu oddzielić wygodę od ochrony. Odczyt UID jest świetny do szafki z filamentem, do włączania maszyny w warsztacie i do eksperymentu z drzwiami wewnętrznymi, przy których i tak zostaje mechaniczny zamek. Nie jest to certyfikowany system kontroli dostępu. Identyfikator karty leci w eter jawnie, podczas procedury antykolizji, zanim ktokolwiek zapyta o hasło. Kto ma chwilę przy Twoim czytniku, może ten numer podejrzeć. Do automatyki biurowej to zwykle akceptowalna cena prostoty. Do drzwi zewnętrznych mieszkania już nie.

Jest jeszcze jedna pułapka zakupowa. Karta płatnicza, legitymacja i bilet komunikacji też często pracują na 13,56 MHz, ale ich treść jest zabezpieczona, a część z nich przy każdym zbliżeniu pokazuje inny identyfikator. Nie rób z nich klucza do własnego projektu. Użyj pustego tagu, który sam kupiłeś i którego zachowanie rozumiesz. Przy okazji nie opieraj zamka na karcie, której utrata zaboli Cię z zupełnie innych powodów.

Sam montaż też ma kolejność, która oszczędza wieczory. Najpierw czytnik ma stabilnie wypisać UID na biurku, z dala od metalu i od cewki przekaźnika. Dopiero potem dopinasz listę uprawnionych, potem przekaźnik na sucho, z diodą zamiast zaczepu, a na końcu zasilacz 12 V i elektrozaczep. Jeśli od razu złożysz wszystko w metalowej puszce, nie będziesz wiedział, czy winić kod, zasilanie, czy blachę.

Dwa popularne układy – PN532 i RC522 oraz to, co potrafi antena

Na stołach warsztatowych królują dwa scalaki firmy NXP. Tańszy moduł z układem MFRC522, sprzedawany jako RC522, jest małą niebieską lub czarną płytką z cewką drukowaną. Droższy PN532 przychodzi zwykle jako czerwona płytka z przełącznikami wyboru interfejsu albo jako moduł z wbudowanym dopasowaniem poziomów logicznych. Oba mówią do kart typu A. Różnią się tym, jak wygodnie rozmawiają z resztą projektu i jak szeroki jest ich świat tagów.

RC522 w praktyce podłączasz po SPI. Sam układ potrafi też inne interfejsy, ale typowy moduł ma pola lutownicze i ścieżki ustawione pod SPI, więc nie warto walczyć z opisem z noty katalogowej wbrew płytce. Do Arduino jest dojrzała biblioteka MFRC522, która czyta UID kart MIFARE i Ultralight bez zgłębiania rejestrów. Zasięg małej anteny to zwykle 2-5 cm, zależnie od tagu, obudowy i tego, czy karta leży płasko, równolegle do cewki. To nie jest czytnik bramkowy. Telefon w grubym etui, pod kątem, często w ogóle nie wejdzie w pole.

PN532 jest bardziej uniwersalny. Na wielu płytkach przełączniki wybierają SPI, I2C albo UART, a właściwe położenie jest nadrukowane przy przełączniku. Nie zgaduj go z pamięci innej rewizji modułu. Układ obsługuje też karty typu B i FeliCa, a w bibliotekach znajdziesz tryb odczytu biernego tagu, z którego korzystamy w tym artykule. Tryby wymiany peer-to-peer i udawania karty istnieją, ale do zamka opartego o UID nie są potrzebne. PN532 bywa też pewniejszy na Raspberry Pi, bo I2C łatwo sprawdzić jednym poleceniem, zanim napiszesz własną pętlę.

Antena na module to obwód rezonansowy dostrojony do 13,56 MHz. Czytnik nie „nasłuchuje radia” w potocznym sensie. Wytwarza zmienne pole, które zasila chip w karcie, a karta odpowiada, modulując obciążenie tego pola. Stąd biorą się dwie cechy, które później wrócą przy obudowie. Po pierwsze zasięg jest krótki i bardzo zależy od powierzchni pętli. Po drugie metal w pobliżu cewki wzbudza prądy wirowe, odbiera energię i rozstraja rezonans. Karta, która na drewnianym blacie czyta się z 4 cm, przyklejona nad stalową ramą drzwi może wymagać dotknięcia anteny.

Różne tagi dają różny UID. Klasyczna karta MIFARE 1K ma często 4 bajty. Nalepka NTAG213 ma zwykle 7 bajtów. Zdarzają się identyfikatory 10-bajtowe. Niektóre nowsze karty, w tym część układów DESFire, da się ustawić tak, by przy każdym zbliżeniu pokazywały identyfikator losowy. Taki tag nigdy nie trafi na stałą listę. Jeśli Twoja karta za każdym razem wypisuje inny numer, to nie jest błąd programu. To właściwość karty i trzeba wymienić tag na taki, który ma numer stały.

Telefon nie zachowuje się jak brelok. Samo przyłożenie Androida albo iPhone’a do RC522 rzadko daje stabilny, powtarzalny UID, na którym dałoby się oprzeć zamek. Nowoczesne systemy celowo nie wystawiają stałego numeru. Jeśli pierwszy bajt odczytu wynosi 08 szesnastkowo, norma traktuje identyfikator jako losowy. Portfel w telefonie i karty płatnicze używają osobnych, zabezpieczonych protokołów. Amatorski czytnik nie powinien ich udawać kluczem. Praktyczna droga do „autoryzowanego telefonu” w projekcie hobbystycznym jest prostsza. Przyklejasz na etui własną nalepkę NTAG i wpisujesz na listę jej stały numer. Aplikacja z Host Card Emulation potrafi udawać kartę, ale to już osobny projekt, nie pierwszy wieczór z modułem.

Prąd też różni te płytki mocniej, niż sugeruje liczba pinów. Włączenie pola na chwilę odczytu potrafi podnieść pobór PN532 do okolic stu miliamperów i więcej. Wyjście 3,3 V na Arduino Uno jest słabe, często liczone na około 50 mA, i przy PN532 bywa przyczyną resetów oraz „losowych” braków odczytu. RC522 jest skromniejszy i nieraz działa z tego pinu, ale gdy odczyt miga, pierwsze podejrzenie i tak powinno paść na zasilanie. Osobny stabilizator 3,3 V, zasilany z linii 5 V, uspokaja oba moduły. Raspberry Pi ma mocniejszą szynę 3,3 V i zwykle jeden czytnik uniesie, o ile nie wisisz na niej już wyświetlaczem, dyskiem i garścią czujników.

Magistrale SPI, I2C i UART – jak dane wędrują z czytnika do mikrokontrolera

Moduł NFC nie wysyła gotowego zdania „karta Kowalskiego”. Wysyła bajty przez jedną z trzech magistral, a biblioteka układa z nich ramki protokołu karty. Wybór magistrali jest wyborem liczby przewodów, długości kabla i tego, które piny zostaną wolne. Do zamka na biurku każda z nich wystarczy. Różnice wychodzą przy obudowie, przy długim kablu w ościeżnicy i przy tym, że na Uno sprzętowy port szeregowy jest jeden.

SPI (Serial Peripheral Interface) jest naturalnym wyborem dla RC522 i dobrym wyborem dla PN532, gdy przewody mają kilkanaście centymetrów. Układ nadrzędny, czyli Arduino albo Pi, wytwarza zegar SCK. Po linii MOSI wysyła bajty do czytnika, po MISO odbiera odpowiedź. Osobny przewód SS, nazywany też chip select albo na module RC522 myląco SDA, wybiera urządzenie. Dopóki ta linia jest w stanie wysokim, czytnik ignoruje zegar. Dzięki temu na jednej magistrali może siedzieć wyświetlacz i czytnik, każdy ze swoim pinem wyboru. SPI jest szybkie i proste, ale źle znosi długą tasiemkę. Każdy przewód to antena, a zbocza zegara lubią się odbijać. Do warsztatowego łączenia trzymaj kable poniżej mniej więcej 20-30 cm, skręcaj pary i nie prowadź ich razem z przewodem cewki przekaźnika.

Na Arduino Uno sprzętowe SPI to piny 11 (MOSI), 12 (MISO) i 13 (SCK). Pin wyboru może być dowolnym cyfrowym, biblioteki RC522 najczęściej używają pinu 10, a resetu pinu 9. Na Mega sprzętowe SPI wędruje na piny 51, 50 i 52. Podłączenie RC522 do pinów „jak w Uno” na Mega jest częstym powodem, dla którego program się kompiluje, a karta milczy. Na Raspberry Pi sprzętowe SPI0 to GPIO10 jako MOSI (pin fizyczny 19), GPIO9 jako MISO (pin 21), GPIO11 jako SCK (pin 23) i GPIO8 jako CE0 (pin 24). Interfejs włącza się w raspi-config, w opcjach interfejsów, po czym w systemie pojawia się urządzenie /dev/spidev0.0.

I2C (Inter-Integrated Circuit) używa dwóch przewodów, SDA i SCL, oraz wspólnej masy. Urządzenia mają adresy. PN532 zgłasza się zwykle pod adresem 7-bitowym 0x24. Na Raspberry Pi polecenie i2cdetect -y 1 powinno pokazać liczbę 24, zanim w ogóle sięgniesz po bibliotekę NFC. To najszybszy test, czy moduł żyje, czy ma zasilanie i czy przełącznik naprawdę stoi w pozycji I2C. Na Uno linie to A4 (SDA) i A5 (SCL), na Mega piny 20 i 21. Magistrala wymaga rezystorów podciągających do 3,3 V. Większość modułów ma je na płytce. Jeśli dołożysz własne, nie podciągaj linii I2C do 5 V, bo w ten sposób podasz piątkę na wejścia układu 3,3 V.

I2C jest wolniejsze od SPI i bardziej wrażliwe na pojemność kabla, za to oszczędza piny i ładnie współżyje z zegarem RTC albo czujnikiem temperatury. Do PN532 na Uno jest wręcz wygodniejsze niż SPI, bo sprzętowy port szeregowy zostaje wolny na komunikaty diagnostyczne do komputera. Na Pi też bywa najspokojniejszą drogą. Adres 0x24 rzadko koliduje z popularnymi modułami, ale drugi PN532 na tej samej magistrali już tak. Wtedy zostaje SPI z osobnymi liniami wyboru albo drugi kontroler I2C, jeśli płytka go ma.

UART (Universal Asynchronous Receiver-Transmitter) to zwykła para TX i RX oraz masa. Nie ma linii zegara. Tempo musi być zgodne po obu stronach. Moduły PN532 w trybie szeregowym często pracują z prędkością 115200 bodów, ale konkretną wartość potwierdź w opisie swojej płytki, bo zdarzają się wolniejsze ustawienia fabryczne. UART dobrze znosi dłuższy, skręcony przewód, dlatego ma sens, gdy czytnik siedzi przy drzwiach, a komputer w puszce kilkadziesiąt centymetrów dalej. Na Raspberry Pi użyjesz /dev/serial0, pamiętając, by wyłączyć konsolę szeregową na tym porcie, inaczej system i czytnik będą mówić naraz. Na Uno sprzętowe UART jest zajęte przez USB. Programowa emulacja portu przy 115200 bodach bywa kapryśna. Jeśli koniecznie chcesz UART na płytce z rodziny Arduino, wygodniej wziąć Mega, które ma dodatkowe porty sprzętowe, albo zostać przy I2C.

Jest reguła, która porządkuje wybór bez tabelki. Uno i tani RC522 prowadzisz po SPI. Uno i PN532 najwygodniej po I2C. Raspberry Pi i PN532 zaczynasz od I2C, bo adres widać od razu. Raspberry Pi i RC522 to praktycznie SPI. Długi kabel między ościeżnicą a sterownikiem lepiej znieść UART-em PN532 niż wiązką SPI z pięcioma równoległymi żyłami.

Zostaje dopasowanie napięć, ważniejsze niż wybór magistrali. Oba czytniki są układami 3,3 V. Zasilanie ich z pinu 5 V potrafi je uszkodzić od razu albo po kilku tygodniach, gdy stabilizator na module się przegrzeje. Raspberry Pi jest tu wdzięczne, bo jego GPIO też pracuje na 3,3 V i linie można łączyć wprost, pin zasilania 3,3 V do VCC modułu, masa do masy. Arduino Uno wystawia na pinach logicznych 5 V. Sygnał 3,3 V wracający z czytnika Uno jeszcze odczyta jako stan wysoki. Odwrotnie jest gorzej. MOSI, SCK i SS o poziomie 5 V wchodzą na wejścia przewidziane na 3,3 V. W internecie pełno zdjęć, na których takie połączenie „działa”. Działa wbrew nocie katalogowej. Poprawnie wstawia się translator poziomów, a przy I2C translator dwukierunkowy, na przykład z tranzystorami MOSFET. Rezystor szeregowy około 1 kΩ bywa stosowany jako kompromis warsztatowy, ale nie jest prawdziwym przesunięciem poziomu. Płytki 3.3 V zgodne z Arduino oraz moduły PN532 z wbudowanym dopasowaniem zdejmują ten problem z listy.

Resetu nie zostawiaj w powietrzu. Wiszący pin RST daje inicjalizację, która raz się udaje, a raz nie, i wtedy winnym wydaje się kod. Podłącz go do pinu opisanego w przykładzie biblioteki albo podciągnij zgodnie z opisem modułu. Linia IRQ jest opcjonalna. Przy pierwszym projekcie możesz ją pominąć i odpytywać czytnik w pętli. Odpytywanie co kilkaset milisekund w zupełności wystarcza do zamka, a człowiek i tak nie przykłada karty na ułamek milisekundy.

Pierwszy odczyt numeru UID w C++ i w Pythonie

Biblioteka ukrywa antykolizję, czyli procedurę, w której czytnik wybiera jedną kartę, gdy w polu jest ich kilka, i odbiera jej numer. Twoim zadaniem jest ten numer pokazać, a potem porównać bajt po bajcie. Nie zamieniaj go od razu na tekst. Spacja, brak zera z przodu albo wielkość liter w zapisie szesnastkowym potrafią sprawić, że ta sama karta raz jest „uprawniona”, a raz nie. Porównanie tablicy bajtów i jej długości jest odporne na takie ozdobniki.

Na Arduino, przy RC522 i bibliotece MFRC522, szkic diagnostyczny wygląda tak. Najpierw tylko wypisuje numer. Listę uprawnionych dopiszesz, gdy zobaczysz rzeczywiste bajty swojej karty, a nie bajty z przykładu w internecie.

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

const byte SS_PIN = 10;
const byte RST_PIN = 9;
MFRC522 rfid(SS_PIN, RST_PIN);

void setup() {
  Serial.begin(9600);
  SPI.begin();
  rfid.PCD_Init();
  Serial.println(F("Czekam na karte"));
}

void loop() {
  if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) {
    return;
  }
  Serial.print(F("UID:"));
  for (byte i = 0; i < rfid.uid.size; i++) {
    Serial.print(rfid.uid.uidByte[i] < 0x10 ? " 0" : " ");
    Serial.print(rfid.uid.uidByte[i], HEX);
  }
  Serial.print(F("  bajtow: "));
  Serial.println(rfid.uid.size);
  rfid.PICC_HaltA();
  rfid.PCD_StopCrypto1();
  delay(800);
}

PICC_IsNewCardPresent sprawdza, czy w polu ktoś odpowiedział na zapytanie. PICC_ReadCardSerial przeprowadza antykolizję i wypełnia strukturę uid. Pole size bywa równe 4 albo 7, więc pętla nie może zakładać czterech bajtów. PICC_HaltA usypia kartę, a PCD_StopCrypto1 zamyka ewentualną sesję szyfru, nawet jeśli w tym szkicu żadnego sektora nie czytałeś. Bez tego niektóre karty wracają w pętli natychmiast, jakby ktoś przykładał je sto razy na sekundę. Krótka przerwa na końcu jest celowa. Zamek nie potrzebuje odczytu co milisekundę.

Gdy numer już znasz, porównanie jest krótkie. Długość musi się zgadzać i każdy bajt musi się zgadzać. Jedna karta na początek wystarczy. Kolejne dopiszesz jako następną tablicę i drugie wywołanie, albo jako prostą listę. Nie trzymaj numeru w postaci napisu sklejonego z monitora szeregowego.

const byte allowedUid[] = {0xDE, 0xAD, 0xBE, 0xEF};
const byte allowedLen = 4;

bool authorized(MFRC522::Uid *uid) {
  if (uid->size != allowedLen) return false;
  for (byte i = 0; i < allowedLen; i++) {
    if (uid->uidByte[i] != allowedUid[i]) return false;
  }
  return true;
}

Na Raspberry Pi przy PN532 po I2C najczytelniejsza jest biblioteka CircuitPython, adafruit-circuitpython-pn532, razem z warstwą Blinka, która udostępnia piny płytki. Po włączeniu I2C i sprawdzeniu adresu 0x24 program wygląda następująco. Metoda read_passive_target zwraca identyfikator albo nic, jeśli w polu nikogo nie było. Czas oczekiwania pół sekundy daje płynną pętlę bez blokowania programu na zawsze.

import board
import busio
from adafruit_pn532.i2c import PN532_I2C

i2c = busio.I2C(board.SCL, board.SDA)
nfc = PN532_I2C(i2c, debug=False)
print("firmware:", nfc.firmware_version)
nfc.SAM_configuration()

while True:
    uid = nfc.read_passive_target(timeout=0.5)
    if uid is None:
        continue
    print("UID:", uid.hex(), "bajtow:", len(uid))

Jeśli firmware_version rzuca wyjątkiem, a i2cdetect nie widzi adresu, nie szukaj błędu w pętli. Wtedy leży zasilanie, masa, przełącznik interfejsu albo brak włączenia I2C. Dopiero stabilny wydruk numeru uprawnia do porównania z listą. W Pythonie naturalnym typem jest bytes.

allowed = (
    bytes.fromhex("04a1b2c3112233"),
)

def is_allowed(uid) -> bool:
    return bytes(uid) in allowed

Dla RC522 na Pi popularna jest biblioteka mfrc522. Jej klasa SimpleMFRC522 i metoda read() bywają wygodne przy kartach MIFARE Classic, ale oprócz numeru próbują czytać treść sektora domyślnym kluczem. Na nalepce NTAG, która nie ma takiej struktury, zachowanie potrafi zaskoczyć, choć sam UID jest dostępny już na etapie antykolizji. Do zamka opartego wyłącznie o numer bezpieczniej oprzeć się o funkcję, która kończy pracę po antykolizji, albo zostać przy PN532 i przykładzie powyżej. Starsze wydania tej biblioteki same ustawiają numerację pinów trybu BOARD i wołają RPi.GPIO. Mieszanie tego z pinami BCM oraz używanie jej bez sprawdzenia na Raspberry Pi 5 kończy się błędami, które wyglądają jak awaria czytnika, a są niezgodnością biblioteki z płytką. Na nowszych generacjach Pi sprawdź, czy wybrany pakiet deklaruje wsparcie, i preferuj dostęp przez jądrowe SPI albo I2C.

Niezależnie od języka, program startowy powinien robić jedną rzecz. Wypisać długość i surowe bajty. Dopiero gdy trzy przyłożenia tej samej karty dają ten sam ciąg, wpisujesz go na listę. Jeśli ciąg się zmienia, wymień tag. Jeśli nie ma żadnego ciągu, nie dodawaj przekaźnika w nadziei, że „przy zamku jakoś zacznie”. Najpierw biurko, potem obudowa, potem zamek.

Metal, zasilanie i zakłócenia, które psują odczyt

NFC na stole i NFC w docelowej obudowie to dwa różne urządzenia. Pole 13,56 MHz jest słabe, a antena na module jest mała i już dostrojona. Każdy kawałek metalu w odległości centymetra od cewki pochłania część energii i przesuwa częstotliwość rezonansu. Objaw jest charakterystyczny. Na drewnie karta czyta się pewnie, po przykręceniu modułu do blachy drzwi odczyt znika albo wymaga mocnego dociśnięcia na środku anteny. Nie leczy się tego zwiększaniem mocy w kodzie, bo te moduły nie mają pokrętła zasięgu. Leczy się geometrią.

Moduł trzymaj w obudowie z tworzywa albo wysuń antenę za metal, w okienko z poliwęglanu. Jeśli czytnik musi siedzieć na stalowych drzwiach, między cewkę a blachę wkleja się cienki arkusz ferrytowy przeznaczony do NFC. Ferryt zamyka pole po stronie metalu i przywraca część zasięgu. Zwykła taśma izolacyjna tego nie zrobi. Odległość kilku milimetrów od blachy bywa ważniejsza niż droższy moduł. Równoległość też ma znaczenie. Karta przykładana bokiem, prostopadle do płytki, sprzęga się słabo. Prowadnica z wydrukowanego plastiku, która zmusza brelok do położenia na płask, poprawia powtarzalność bardziej niż kolejna biblioteka.

Druga rodzina zakłóceń idzie po przewodach. Długie, równoległe żyły SPI zbierają impulsy z zasilacza impulsowego, z silnika i z cewki przekaźnika. Objaw to UID ucinany w połowie, odczyt co drugi raz albo zawieszenie biblioteki aż do resetu. Skróć wiązkę, skręć SCK z masą, a MOSI z MISO, i daj masę osobnym, krótkim przewodem, nie „po obudowie kiedyś”. Przy module, możliwie blisko pinów VCC i GND, wlutuj kondensator ceramiczny 100 nF. Równolegle może siedzieć elektrolit 10 µF. To nie jest ozdoba. Czytnik bierze prąd szpilkami w chwili włączenia pola, a cienki przewód zasilania nie nadąża. Napięcie siada, układ się restartuje, a w logu wygląda to jak kapryśna karta.

Przekaźnik jest tu szczególnym wrogiem, bo dokładnie w chwili sukcesu, gdy program już rozpoznał kartę, cewka dostaje prąd i generuje stromy impuls. Jeśli antena leży obok przekaźnika, pole tego impulsu potrafi zgubić sesję albo zresetować mikrokontroler, i zamek „działa tylko raz”. Odsuń przekaźnik od anteny o kilka centymetrów, a lepiej do osobnej przegrody. Cewkę przekaźnika, jeśli sterujesz ją bezpośrednio, zablokuj diodą w kierunku zaporowym wobec zasilania, równolegle do uzwojenia. Moduły z przekaźnikiem zwykle mają taki tłumik na płytce, ale nie zaszkodzi o nim wiedzieć, gdy kiedyś użyjesz gołej cewki. Prąd cewki nie może wracać tą samą cienką masą, którą wraca prąd czytnika. Wspólny punkt masy zrób przy zasilaczu, nie przy antenie.

Zasilacze impulsowe małej mocy, zwłaszcza tanie ładowarki bez zapasu prądu, dokładają własne śmieci. Do prób warsztatowych stabilniejsze bywa zasilanie z dobrego zasilacza 5 V i osobnego stabilizatora 3,3 V niż z pinu 3,3 V na Uno. Jeśli odczyt pada tylko wtedy, gdy z tej samej listwy startuje silnik albo świetlówka z przetwornicą, masz odpowiedź. Odfiltruj zasilanie czytnika i nie prowadź jego kabla wzdłuż przewodu silnika. Ekran na kablu sygnałowym pomaga dopiero wtedy, gdy ekran jest podłączony do masy z jednej strony, przy sterowniku. Ekran podpięty na obu końkach do różnych mas potrafi wciągnąć pętlę prądu i pogorszyć sprawę.

Jest prosty eksperyment, który warto zrobić przed wierceniem otworów. Połóż działający zestaw na biurku i zanotuj, z jakiej odległości karta jeszcze działa. Potem przysuwaj kawałek blachy od spodu modułu i zobacz, kiedy odczyt zniknie. Potem kliknij przekaźnikiem w odległości 2 cm od anteny i w odległości 15 cm. Ta próba mówi więcej niż ogólna rada „uważaj na zakłócenia”. Jeśli w docelowym miejscu zasięg spadnie do zera, najpierw popraw mechanikę anteny. Dopiero stabilny odczyt w obudowie uprawnia do podłączenia zaczepu.

Ciepło i zimno też potrafią rozstroić tani moduł, choć rzadziej niż metal. Antena drukowana na laminacie zmienia wymiary, a elementy dopasowujące nie są laboratoryjnym filtrem. Jeśli zamek ma wisieć na nieogrzewanej bramie, przetestuj go w tej temperaturze, a nie tylko na kuchennym stole. I nie zamykaj modułu w szczelnej metalowej puszce „dla bezpieczeństwa”. Pole przez pełną blachę nie przejdzie. Bezpieczeństwo mechaniczne załatwia puszka od strony przewodów i śrub, a okno nad anteną zostaje dielektryczne.

Zamek na przekaźniku i rozsądne granice zaufania do numeru UID

Gdy UID czyta się pewnie w docelowym miejscu, zamek jest już głównie decyzją elektryczną. Program po rozpoznaniu uprawnionej karty zmienia stan pinu na ustalony czas. Pin nie powinien zasilać elektrozaczepu. Pin steruje modułem przekaźnika albo tranzystorem, a prąd zaczepu płynie z osobnego zasilacza, najczęściej 12 V. Arduino zasilane z USB nie udźwignie cewki zaczepu i nie po to ma pin cyfrowy, by puszczać przezeń ampery.

Rozdziel strony. Czytnik może być przy drzwiach. Sterownik, przekaźnik i zasilacz zaczepu trzymaj po stronie chronionej, w środku. Na zewnątrz nie wystawiaj przewodu, którego zwarcie albo podanie napięcia otwiera drzwi. Jeśli ktoś ma dostęp do żyły idącej wprost na cewkę, program, lista kart i szyfrowanie nie mają znaczenia. Tanie moduły „z optoizolacją” traktuj jako wygodny sposób sterowania cewką, a nie jako barierę między siecią a Raspberry Pi. Do tego projektu wybierz elektrozaczep niskonapięciowy. Nie prowadź przez amatorski przekaźnik zasilania sieciowego tylko dlatego, że styk ma nadruk 250 V.

Wiele niebieskich modułów przekaźnikowych załącza cewkę stanem niskim. Zworka między VCC a JD-VCC oznacza, że cewka bierze prąd z tej samej piątki co logika. Zdjęcie zworki pozwala zasilić cewkę z osobnej piątki, a VCC zostawić dla strony sterującej. Masy łącz zgodnie z opisem konkretnego modułu. W programie nie zakładaj w ciemno, że wysoki stan oznacza „otwórz”. Zrób stałą i sprawdź ją na sucho, patrząc na diodę modułu, zanim podepniesz zaczep.

Na Arduino, jako kontynuacja wcześniejszego szkicu, wystarczy pin ustawiony na bezpieczny stan jeszcze przed inicjalizacją czytnika. Inicjalizacja SPI potrafi trwać, a pin pozostawiony jako wejście potrafi na ułamek sekundy drgnąć i cyknąć przekaźnikiem przy każdym resecie. To nie jest drobiazg, gdy przekaźnik trzyma drzwi.

const byte RELAY_PIN = 7;
const byte RELAY_OPEN = LOW;   // zmien na HIGH, jesli modul zalacza stanem wysokim
const byte RELAY_IDLE = HIGH;  // stan przeciwny do RELAY_OPEN
const unsigned long OPEN_MS = 3000;

void setup() {
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, RELAY_IDLE);
  Serial.begin(9600);
  SPI.begin();
  rfid.PCD_Init();
}

void openBriefly() {
  digitalWrite(RELAY_PIN, RELAY_OPEN);
  delay(OPEN_MS);
  digitalWrite(RELAY_PIN, RELAY_IDLE);
}

W pętli, po udanym odczycie, wołasz openBriefly() tylko wtedy, gdy authorized zwróci prawdę. Potem i tak wykonujesz PICC_HaltA, żeby karta trzymana przy antenie nie otwierała zamka w kółko. Trzy sekundy to typowy impuls elektrozaczepu. Za krótki impuls człowiek odczuwa jako „nie zdążyłem nacisnąć klamki”. Za długi zostawia drzwi odblokowane bez powodu.

Na Raspberry Pi ten sam pomysł, przy PN532 i pinie GPIO17, wygląda tak. Stan spoczynkowy ustawiasz natychmiast po utworzeniu wyjścia.

import time
import board
import busio
from digitalio import DigitalInOut, Direction
from adafruit_pn532.i2c import PN532_I2C

i2c = busio.I2C(board.SCL, board.SDA)
nfc = PN532_I2C(i2c, debug=False)
nfc.SAM_configuration()

relay = DigitalInOut(board.D17)
relay.direction = Direction.OUTPUT
relay.value = False  # False = spoczynek, jesli modul zalacza stanem wysokim

allowed = (bytes.fromhex("04a1b2c3112233"),)

while True:
    uid = nfc.read_passive_target(timeout=0.5)
    if uid is None or bytes(uid) not in allowed:
        continue
    relay.value = True
    time.sleep(3)
    relay.value = False
    time.sleep(1)

Jeśli Twój moduł załącza się stanem niskim, odwróć znaczenia True i False, ale spoczynek po starcie programu nadal musi oznaczać drzwi zamknięte. Sekunda przerwy po impulsie daje czas na odsunięcie karty i chroni przed serią impulsów.

Elektrozaczep i zwora elektromagnetyczna reagują odwrotnie, więc dobierz zachowanie do mechanizmu. Zwykły elektrozaczep puszcza język na czas impulsu, a drzwi i tak trzyma zapadka, dopóki ktoś nie naciśnie klamki. Zwora trzyma skrzydło tak długo, jak ma zasilanie. Puszczenie cewki otwiera przejście. Przy zaniku prądu zwora puszcza. Takie zachowanie, nazywane fail-safe, bywa pożądane na drodze, którą ludzie mają opuścić przy awarii. Odwrotne, fail-secure, zostawia przejście zamknięte bez prądu. Do szafki z narzędziami często wolisz, by awaria programu nie otwierała drzwiczek. Dlatego impuls, który sam wraca do stanu spoczynku, jest lepszy niż „włącz i trzymaj, aż program znów coś powie”. Ten projekt nie zastępuje drzwi ewakuacyjnych ani atestowanego zamka. Jeśli przejście jest drogą wyjścia z budynku, dobór zaczepu i skutków zaniku prądu zostaw projektowi, który uwzględnia przepisy, a nie tylko pin GPIO.

Telefon w roli klucza oprzyj na nalepce przyklejonej do etui, wpisanej na listę jak każda inna karta. Samo machnięcie telefonem, bez takiej nalepki i bez osobnej aplikacji udającej kartę, zwykle nie da powtarzalnego numeru. Nie próbuj „nauczyć” czytnika karty płatniczej z portfela. Nie po to jest ten zamek, a numer i tak bywa losowy albo bezużyteczny bez kryptografii, której amatorski szkic nie przeprowadza.

Sam UID ma granicę, którą trzeba znać, zanim powiesisz zaczep na drzwiach do wartościowych rzeczy. Numer nie jest hasłem. Jest identyfikatorem wysyłanym jawnie. Da się go podsłuchać z bliska i da się spotkać karty, które potrafią pokazać cudzy numer. Nie opisuję, jak to zrobić, bo do budowy własnego zamka ta wiedza nie jest potrzebna. Wystarczy wniosek. Lista UID chroni przed przypadkowym brelokiem kolegi, nie przed kimś, kto celowo chce wejść. Kryptografia starszych kart MIFARE Classic, nazywana Crypto1, jest publicznie złamana, więc odczyt „zabezpieczonego sektora” domyślnym albo złamanym kluczem też nie staje się nagle poważną ochroną. Jeśli kiedyś będziesz potrzebował mocniejszego rozróżnienia osób, szukaj kart z prawdziwym uwierzytelnieniem, takich jak DESFire, i traktuj to jako osobny temat, a nie jako dopisek do tego szkicu.

Jest też granica fizyczna, starsza niż NFC. Kto otworzy obudowę i zewrze styki przekaźnika, wejdzie bez karty. Kto podmieni czytnik na końcu długiego kabla SPI prowadzonego przez niechronioną strefę, może podstawić dowolny numer. Dlatego decyzja „otwórz” i zasilanie zaczepu zostają w środku, a na zewnątrz jest tylko antena albo cały moduł w miejscu, którego nie da się spokojnie rozebrać. Do automatyki biurowej, gdzie stawką jest włączona lampa albo odblokowana szafka z papierem, ta architektura jest w sam raz.

Warto dopisać jeszcze jedną rzecz, która nie wymaga nowych przewodów. Wypisuj na porcie szeregowym albo w logu czas, odczytany numer i decyzję. Przy trzech użytkownikach wydaje się to zbędne. Przy pierwszej skardze „wczoraj nie wpuściło” log mówi, czy karta w ogóle doszła do programu. Milczenie logu oznacza problem z polem, zasilaniem albo anteną. Numer spoza listy oznacza żywego czytelnika i martwy wpis w tablicy, na przykład po tym, jak ktoś wymienił nalepkę na telefonie.

Złóż to w kolejności, która daje się debugować. Najpierw sam wydruk UID na biurku. Potem ten sam wydruk w docelowej obudowie, przy metalu i przy docelowym zasilaczu. Potem lista uprawnionych i dioda zamiast przekaźnika. Potem przekaźnik bez zaczepu. Na końcu elektrozaczep 12 V, krótki impuls i test z kartą uprawnioną, kartą obcą oraz z brakiem karty w chwili resetu. Jeśli przy resecie zaczep cyka, popraw stan spoczynkowy pinu, zanim zaczniesz poprawiać antenę. Gdy te trzy próby przechodzą, masz nie demonstrację z filmu, tylko układ, który da się powiesić na szafce i poprawiać dalej. Dopisanie drugiej karty, wydłużenie impulsu albo wysłanie zdarzenia do automatyki biurowej jest już tylko zmianą kilku linii wokół porównania, które właśnie zaczęło działać.