Dzisiaj opowiem o module RC522 RFID, opartym na chipie MFRC522. Zasilanie 3,3V, zasięg wykrywania do 6cm. Przeznaczony do odczytu i zapisu tagów RFID z częstotliwością 13,56 MHz. Częstotliwość w tym przypadku jest bardzo ważna, ponieważ tagi RFID występują w trzech zakresach częstotliwości:

• Oznaczenia pasma LF (125-134 kHz)


• Tagi pasma HF (13,56 MHz)


• Tagi pasma UHF (860-960 MHz)

W szczególności moduł ten współpracuje z tagami zakresu HF, w szczególności z protokołem MIFARE.

Do pracy z modułem można skorzystać ze standardowej biblioteki RFID zawartej w IDE Arduino istnieje jednak inna biblioteka napisana specjalnie dla tego modułu - MFRC522 (1 Mb). Obie biblioteki są dość wygodne, ale MFRC522 ma więcej specjalnych funkcji, które pozwalają zminimalizować wynikowy kod programu.

Połączenie

Niektóre napotkają problem — nazwy pinów w większości samouczków i samouczków mogą nie odpowiadać pinoutowi w twoim module. Jeśli pin SS jest wskazany na szkicach, ale Twój moduł go nie ma, to najprawdopodobniej jest oznaczony jako SDA. Poniżej podam tabelę połączeń modułów dla najpopularniejszych płyt.

MFRC522	Arduino Uno	Arduino Mega	Arduino Nano v3	Arduino Leonardo/Mikro	Arduino Pro Micro
RST	9	5	D9	RESET/ICSP-5	RST
SDA(SS)	10	53	D10	10	10
MOSI	11 (ICSP-4)	51	D11	ICSP-4	16
MISO	12 (ICSP-1)	50	D12	ICSP-1	14
SCK	13 (ICSP-3)	52	D13	ICSP-3	15
3,3V	3,3V	3,3V	Stabilizator 3,3V	Stabilizator 3,3V	Stabilizator 3,3V
GND	GND	GND	GND	GND	GND

Piny sterujące SS(SDA) i RST są wyspecyfikowane na szkicu, więc jeśli twoja płytka jest inna niż ta, którą będę używał w moich przykładach, a ja używam UNO R3, podaj piny z tabeli na początku szkicu:

#define SS_PIN 10 #define RST_PIN 9

Przykład #1: Odczytanie numeru karty

Rozważ przykład z biblioteki RFID - cardRead. Nie podaje danych z karty, a jedynie jej numer, który zwykle wystarcza do wielu zadań.

#include #include #define SS_PIN 10 #define RST_PIN 9 RFID rfid(SS_PIN, RST_PIN); // Dane o numerze karty przechowywane są w 5 zmiennych, zapamiętamy je, aby sprawdzić, czy już taką kartę odczytaliśmy int serNum0; int serNum1; intserNum2; int serNum3; int serNum4; void setup() ( Serial.begin(9600); SPI.begin(); rfid.init(); ) void loop() ( if (rfid.isCard()) ( if (rfid.readCardSerial()) ( // Porównaj numer karty z poprzednim numerem karty if (rfid.serNum != serNum0 && rfid.serNum != serNum1 && rfid.serNum != serNum2 && rfid.serNum != serNum3 && rfid.serNum != serNum4) ( /* If karta jest - nowa, potem przeczytaj*/ Serial.println(" "); Serial.println("Znaleziono kartę"); serNum0 = rfid.serNum; serNum1 = rfid.serNum; serNum2 = rfid.serNum; serNum3 = rfid. serNum; serNum4 = rfid.serNum; //Wydrukuj numer karty Serial.println("Numer karty:"); Serial.print("Grudzień: "); Serial.print(rfid.serNum,DEC); Serial.print(" , "); Serial .print(rfid.serNum,DEC); Serial.print(", "); Serial.print(rfid.serNum,DEC); Serial.print(", "); Serial.print(rfid. serNum,DEC); Serial.print(", "); Serial.print(rfid.serNum,DEC); Serial.println(" "); Serial.print("Hex: "); Serial.print(rfid.serNum ,HEX); Serial .print(", "); Serial.print(rfid.serNum,HEX); Serial.pr int(", "); Serial.print(rfid.serNum,HEX); Serial.print(", "); Serial.print(rfid.serNum,HEX); Serial.print(", "); Serial.print(rfid.serNum,HEX); Serial.println(" "); ) else ( /* Jeśli jest to już odczytana karta, po prostu wypisz kropkę */ Serial.print("."); ) ) ) rfid.halt(); )

Szkic wgrany, dioda zasilania na module zaświeciła się, ale moduł nie reaguje na kartę? Nie panikuj ani nie biegnij w poszukiwaniu „poprawnych” przykładów pracy. Najprawdopodobniej na jednym z pinów po prostu nie ma kontaktu – otwory na płytce są nieco większe niż grubość zworki, więc warto spróbować je przestawić. Czy dioda LED na płycie nie świeci? Spróbuj zmienić zworkę, która prowadzi do 3,3V i upewnij się, że jest podłączona do 3,3V na płycie, zasilanie 5V może łatwo zabić twoją płytkę.

Powiedzmy, że wszystko działało dla Ciebie. Następnie odczytując tagi przez moduł RFID w monitorze Port szeregowy zobaczymy:

Tutaj przeczytałem 3 różne znaki i jak widać, z powodzeniem przeczytał wszystkie 3.

Przykład #2: Odczytywanie danych z karty

Rozważmy bardziej rozbudowaną opcję - odczyta nie tylko numer karty, ale także wszystkie dane dostępne do odczytu. Tym razem weźmiemy przykład z biblioteki MFRC522 - DumpInfo.

#include #include #define RST_PIN 9 // #define SS_PIN 10 // MFRC522 mfrc522(SS_PIN, RST_PIN); // Utwórz instancję MFRC522 void setup() ( Serial.begin(9600); // Zainicjuj monitor portu szeregowego podczas (!Serial); // Nie rób nic, dopóki nie zostanie otwarty (dla Arduino na układzie ATMEGA32U4) SPI.begin(); // Zainicjuj magistralę SPI mfrc522.PCD_Init() // Zainicjuj moduł RFID ShowReaderDetails() // Wyświetl dane o module MFRC522 Serial.println(F("Skanuj PICC, aby zobaczyć UID, typ i bloki danych.. ." )); ) void loop() ( // Szukam nowa mapa if (! mfrc522.PICC_IsNewCardPresent()) ( return; ) // Wybierz jedną z kart if (! mfrc522.PICC_ReadCardSerial()) ( return; ) // Zrzuć dane z karty mfrc522.PICC_DumpToSerial(&(mfrc522.uid) ); ) void ShowReaderDetails() ( // Pobierz numer wersji modułu byte v = mfrc522.PCD_ReadRegister(mfrc522.VersionReg); Serial.print(F("Wersja oprogramowania MFRC522: 0x")); Serial.print(v, HEX); if (v == 0x91) Serial.print(F(" = v1.0")); else if (v == 0x92) Serial.print(F(" = v2.0")); else Serial.print(F (" (nieznane)")); Serial.println(""); // Gdy otrzymamy 0x00 lub 0xFF, transmisja danych zostanie przerwana, jeśli ((v == 0x00) || (v == 0xFF)) ( Serial. println( F("OSTRZEŻENIE: Błąd komunikacji, czy MFRC522 jest prawidłowo podłączony?")); ) )

Jeśli poprzedni przykład działał bez błędów, to również nie powinno stanowić problemu. Chociaż przepustka na metro, która w poprzednim przykładzie bez problemu wydała numer karty, okazała się w tym przypadku mieć niezdefiniowany typ danych, a moduł nie mógł odczytać niczego poza numerem karty.

W efekcie po odczytaniu danych z karty otrzymujemy jej typ, identyfikator oraz dane z 16 sektorów pamięci. Należy zauważyć, że karty MIFARE 1K składają się z 16 sektorów, każdy sektor składa się z 4 bloków, a każdy blok zawiera 16 bajtów danych.

Przykład #3: Zapisywanie nowego identyfikatora na karcie

W tym przykładzie rozważymy zmianę identyfikatora karty (UID). Należy pamiętać, że nie wszystkie karty obsługują zmianę identyfikatora. Karta może być zapisywalna, ale to tylko oznacza, że ​​dane są zapisywalne. Niestety karty, które miałem w rękach nie obsługiwały przepisywania UID, ale na wszelki wypadek podam tutaj kod szkicu.

#include #include /* Ustaw tutaj nowy UID */ #define NEW_UID (0xDE, 0xAD, 0xBE, 0xEF) #define SS_PIN 10 #define RST_PIN 9 MFRC522 mfrc522(SS_PIN, RST_PIN); MFRC522::MIFARE_Key; void setup() ( Serial.begin(9600); while (!Serial); SPI.begin(); mfrc522.PCD_Init(); Serial.println(F("Ostrzeżenie: ten przykład nadpisuje UID karty zmiennej UID, używaj ostrożnie!")); for (bajt i = 0; i< 6; i++) { key.keyByte[i] = 0xFF; } } void loop() { if (! mfrc522.PICC_IsNewCardPresent() || ! mfrc522.PICC_ReadCardSerial()) { delay(50); return; } // Считываем текущий UID Serial.print(F("Card UID:")); for (byte i = 0; i < mfrc522.uid.size; i++) { Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "); Serial.print(mfrc522.uid.uidByte[i], HEX); } Serial.println(); // Записываем новый UID byte newUid = NEW_UID; if (mfrc522.MIFARE_SetUid(newUid, (byte)4, true)) { Serial.println(F("Wrote new UID to card.")); } // Halt PICC and re-select it so DumpToSerial doesn"t get confused mfrc522.PICC_HaltA(); if (! mfrc522.PICC_IsNewCardPresent() || ! mfrc522.PICC_ReadCardSerial()) { return; } // Считываем данные с карты Serial.println(F("New UID and contents:")); mfrc522.PICC_DumpToSerial(&(mfrc522.uid)); delay(2000); }

Przykład #4: Zapisywanie danych na karcie

I wreszcie to, do czego doszliśmy od tak dawna – zapisywanie danych na karcie. „Najsłodszą” częścią pracy z modułem jest możliwość zrobienia kopii istniejącej mapy, dodania czegoś lub zmiany, jest to o wiele ciekawsze niż samo czytanie.

Zmieńmy jeden z bloków danych na mapie:

#include #include #define RST_PIN 9 #define SS_PIN 10 MFRC522 mfrc522(SS_PIN, RST_PIN); MFRC522::MIFARE_Key; void setup() ( Serial.begin(9600); while (!Serial); SPI.begin(); mfrc522.PCD_Init(); // Przygotuj klucz // użyj klucza FFFFFFFFFFFFh, który jest standardem pustych kart dla ( bajt i = 0 i< 6; i++) { key.keyByte[i] = 0xFF; } Serial.println(F("Scan a MIFARE Classic PICC to demonstrate read and write.")); Serial.print(F("Using key (for A and B):")); dump_byte_array(key.keyByte, MFRC522::MF_KEY_SIZE); Serial.println(); Serial.println(F("BEWARE: Data will be written to the PICC, in sector #1")); } void loop() { // Ждем новую карту if (! mfrc522.PICC_IsNewCardPresent()) return; // Выбираем одну из карт if (! mfrc522.PICC_ReadCardSerial()) return; // Показываем подробности карты Serial.print(F("Card UID:")); dump_byte_array(mfrc522.uid.uidByte, mfrc522.uid.size); Serial.println(); Serial.print(F("PICC type: ")); byte piccType = mfrc522.PICC_GetType(mfrc522.uid.sak); Serial.println(mfrc522.PICC_GetTypeName(piccType)); // Проверяем совместимость if (piccType != MFRC522::PICC_TYPE_MIFARE_MINI && piccType != MFRC522::PICC_TYPE_MIFARE_1K && piccType != MFRC522::PICC_TYPE_MIFARE_4K) { Serial.println(F("This sample only works with MIFARE Classic cards.")); return; } // В этом примере мы используем первый сектор данных карты, блок 4 byte sector = 1; byte blockAddr = 4; byte dataBlock = { // Данные, которые мы запишем на карту 0x01, 0x02, 0x03, 0x04, // 1, 2, 3, 4, 0x05, 0x06, 0x07, 0x08, // 5, 6, 7, 8, 0x08, 0x09, 0xff, 0x0b, // 9, 10, 255, 12, 0x0c, 0x0d, 0x0e, 0x0f // 13, 14, 15, 16 }; byte trailerBlock = 7; byte status; byte buffer; byte size = sizeof(buffer); // Аутентификация Serial.println(F("Authenticating using key A...")); status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid)); if (status != MFRC522::STATUS_OK) { Serial.print(F("PCD_Authenticate() failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); return; } // Показываем текущие данные сектора Serial.println(F("Current data in sector:")); mfrc522.PICC_DumpMifareClassicSectorToSerial(&(mfrc522.uid), &key, sector); Serial.println(); // Читаем данные из блока Serial.print(F("Reading data from block ")); Serial.print(blockAddr); Serial.println(F(" ...")); status = mfrc522.MIFARE_Read(blockAddr, buffer, &size); if (status != MFRC522::STATUS_OK) { Serial.print(F("MIFARE_Read() failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); } Serial.print(F("Data in block ")); Serial.print(blockAddr); Serial.println(F(":")); dump_byte_array(buffer, 16); Serial.println(); Serial.println(); // Аутентификация Serial.println(F("Authenticating again using key B...")); status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_B, trailerBlock, &key, &(mfrc522.uid)); if (status != MFRC522::STATUS_OK) { Serial.print(F("PCD_Authenticate() failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); return; } // Записываем данные в блок Serial.print(F("Writing data into block ")); Serial.print(blockAddr); Serial.println(F(" ...")); dump_byte_array(dataBlock, 16); Serial.println(); status = mfrc522.MIFARE_Write(blockAddr, dataBlock, 16); if (status != MFRC522::STATUS_OK) { Serial.print(F("MIFARE_Write() failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); } Serial.println(); // Читаем данные снова, чтобы проверить, что запись прошла успешно Serial.print(F("Reading data from block ")); Serial.print(blockAddr); Serial.println(F(" ...")); status = mfrc522.MIFARE_Read(blockAddr, buffer, &size); if (status != MFRC522::STATUS_OK) { Serial.print(F("MIFARE_Read() failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); } Serial.print(F("Data in block ")); Serial.print(blockAddr); Serial.println(F(":")); dump_byte_array(buffer, 16); Serial.println(); Serial.println(F("Checking result...")); byte count = 0; for (byte i = 0; i < 16; i++) { if (buffer[i] == dataBlock[i]) count++; } Serial.print(F("Number of bytes that match = ")); Serial.println(count); if (count == 16) { Serial.println(F("Success:-)")); } else { Serial.println(F("Failure, no match:-(")); Serial.println(F(" perhaps the write didn"t work properly...")); } Serial.println(); // Выводим данные Serial.println(F("Current data in sector:")); mfrc522.PICC_DumpMifareClassicSectorToSerial(&(mfrc522.uid), &key, sector); Serial.println(); mfrc522.PICC_HaltA(); mfrc522.PCD_StopCrypto1(); } void dump_byte_array(byte *buffer, byte bufferSize) { for (byte i = 0; i < bufferSize; i++) { Serial.print(buffer[i] < 0x10 ? " 0" : " "); Serial.print(buffer[i], HEX); } }

W efekcie otrzymujemy mapę ze zmodyfikowanym blokiem danych:

Teraz, gdy nauczysz się czytać i zapisywać bloki danych kart, możesz eksperymentować z tagami, które najprawdopodobniej masz - przepustkami, biletami komunikacji miejskiej. Spróbuj odczytać i zapisać dane z tych kart, kilka zduplikowanych kart nigdy nie zaszkodzi, prawda?)

To wszystko, subskrybuj i śledź publikacje. Następnym razem omówię i pokażę, jak dodać niestandardowe znaki do standardowego wyświetlacza 1602 znaków, skutecznie dodając grafikę do wyświetlacza.

19 września 2013 o 18:32

Budżetowy czytnik RFID UHF i jego rozwój

• Technologie bezprzewodowe

Witam Szanowne Panie i Panowie.
Najtańszy czytnik RFID UHF lub czytnik EPC Gen2 kosztuje w detalu co najmniej 200 USD.

Poniżej opisano, w jaki sposób można zrobić działający czytnik RFID UHF z części za 10 USD i jak można z tego skorzystać.

Większość nowoczesnych czytników RFID w standardzie EPC Gen2 wykorzystuje specjalistyczne chipy. Produkują je firmy Impinj, AMS i Phychips. Najtańsze żetony kosztują około 20 USD w partiach po 1000 sztuk. Czytniki RFID okazują się cudowne: wydajne, zwinne i dalekiego zasięgu – ale drogie.
Wiosną tego roku w Internecie pojawił się artykuł „Simple Low Cost UHF RFID Reader” o tym, jak zmontować działający czytnik RFID z typowych komponentów radiowych, które w sprzedaży detalicznej kosztują ok. 5 USD. Pomysł wydaje się prosty, ale wdrożenie doczekało się dopiero od niedawna. Założeniem rozwoju jest fakt, że bardzo często w pobliżu anteny trzeba powoli odliczać kilka trzech znaków i nie trzeba płacić dużych pieniędzy za czytnik o stawce 200-500 znaków za sztukę. druga. Schemat blokowy czytnika pokazano na rysunku.


Jej piękno tkwi w prostocie. Podstawą jest konwencjonalny mikrokontroler generujący na odnodze GPIO sygnały w standardzie EPC Gen2 potrzebne do odpytywania tagu. Sygnały są przesyłane do układu nadajnika Melexis TH72035, a następnie do anteny przez sprzęgacz Johanson 0910CF15B0100. Odbiornik montowany jest na pojedynczym komparatorze MAX931 według poniższego schematu.


Sygnały logiczne z odbiornika przesyłane są do innego pinu GPIO mikroprocesora. Otrzymujemy prosty programowy czytnik RFID UHF. Oczywiście napisanie miękkiego czytnika RFID EPC Gen2 to nie funt rodzynek. Ale jeśli jasno określisz cele i użyjesz tylko właściwego podzbioru protokołu EPC Gen2, to zadanie zostanie znacznie uproszczone.
Autorzy opisywanego projektu uważają umieszczenie wszystkich komponentów za jeden z celów jego dalszego rozwoju. Czytnik RFID na jednej planszy. Ale czy nie byłoby ciekawiej pójść w przeciwnym kierunku? Czytnik należy podzielić na fizycznie oddzielne moduły funkcjonalne, a następnie z różnych modułów zbudować czytnik RFID o niezbędnych właściwościach. Wszystko poniżej to tylko pomysł, bez szczegółowego opracowania.

Oczywiste jest, że główny moduł jest oparty na mikroprocesorze. Prawdopodobnie trzeba to zrobić na Cortex-M0, wyjście na złącza UART i USB w celu sterowania czytnikiem. Aby podłączyć moduł nadawczo-odbiorczy, użyj złącza 6-pinowego: Rx, Tx, 2 do zasilania transceivera, 2 GPIO. Takie złącza mogą być wykonane 2-4, o ile wystarczą wyjścia mikroprocesora.
Moduł nadawczo-odbiorczy będzie podłączony do modułu mikroprocesorowego bezpośrednio lub za pomocą krótkiego kabla. Być może konieczne jest wykonanie kilku wariantów modułów nadawczo-odbiorczych o różnej mocy i cenie, ale z tym samym złączem. Piąty pin złącza może być użyty do włączenia transceivera, a szósty może być użyty do pewnego rodzaju czujnika, jeśli to konieczne. Sensowne jest wykonanie płytki drukowanej transceivera z metalizowanymi półotworami końcowymi. Następnie można go przylutować do płytek drukowanych z różnymi antenami lub płytka drukowana ze złączem koncentrycznym SMA.
Tak więc łącząc moduł mikroprocesorowy i moduł nadawczo-odbiorczy otrzymujemy czytnik RFID. Ale właśnie ze względu na to nie warto grodzić ogrodu. Chodźmy dalej. Do 6-pinowego złącza modułu mikroprocesorowego podłączmy zamiast transceivera płytkę ze sterownikiem RS422 i gniazdem RJ45 (para 1 - odbiór, para 2 - nadawanie, 3 - zasilanie, 4 - GPIO). To samo włożymy do transceivera. Oczywiste jest, że teraz można połączyć moduł mikroprocesorowy i transceiver za pomocą dowolnego patchcordu lub użyć do połączenia biurowego SCS. Ogólnie antena może być umieszczona bardzo daleko od modułu mikroprocesorowego. I bez naciągu.
No to nie wszystko :) RS422 to autobus. Transceiver może pomieścić chip typu D-flip-flop. Połącz moduły nadawczo-odbiorcze szeregowo za pomocą patchcordów. To prawda, że ​​drugie złącze RJ45 lub rozdzielacz T jest potrzebne, jeśli zamiast D-flip-flop zainstalowany jest licznik synchroniczny. Za pomocą dwóch GPIO w czwartej parze UTP możesz wybrać żądany transceiver. Okazuje się, że czytnik RFID jest rozproszony, jak na zdjęciu.


Dlaczego USB jest potrzebne: ale żeby móc podłączyć czytnik do tabletu z Androidem.

Rozwiązanie ma zastosowanie tam, gdzie nie są potrzebne duże prędkości i zasięg odczytu tagów.
1. Nie nadaje się do gastronomii. To są sklepy RFID przyszłości. A obecne sklepy RFID to domy towarowe (obuwie i ubrania). Tam czytniki RFID są już wykorzystywane w przymierzalniach (wraz z interaktywnym wyświetlaczem), przy kasach i inteligentnych półkach z towarami.
2. Magazyny z europaletami (łańcuch modułów nadawczo-odbiorczych gdzie znajdują się lewe rogi palet).
3. System dostępu do różnych wydarzeń publicznych.
4. Prawdopodobnie gdzieś indziej.

Czytnik RFID - karty i breloki
na mikrokontrolerze ATtiny13

Źródło: www.serasidis.gr
Vassilis Serasidis
Tłumaczenie: Vadim na zlecenie RadioLotsman

W ostatnim czasie dużą popularnością cieszą się różne projekty oparte na kluczach RFID stosowanych w systemach bezpieczeństwa, ochrony i kontroli dostępu. W niektórych przedsiębiorstwach i organizacjach takie systemy uzupełniają specjalistyczne oprogramowanie, służą do ustalania czasu pracy, rozliczania wartości materiałowych itp.

Każdy system identyfikacji radiowej (RFID) składa się z czytnika (czytnika, czytnika lub interrogatora) i transpondera (znanego również jako tag RFID, czasami używa się również określenia tag RFID). W artykule rozważymy proste urządzenie do odczytu kluczy RFID, które obsługują protokół EM4100 i działają z częstotliwością 125 kHz. Ten typ Klucze RFID mogą mieć postać breloka lub karty kredytowej (rysunek poniżej).

Głównym elementem czytnika jest mikrokontroler Atmel AVR ATtiny13 , który odczytuje 10-cyfrowy unikalny numer identyfikacyjny klucza i przesyła go w kodowaniu ASCII przez interfejs szeregowy (UART) z szybkością 2400 b/s do urządzenia hosta. Innymi słowy, czytnik jest osobnym modułem podłączonym do głównego procesora lub mikrokontrolera systemu (rysunek 2).

pryncypialny Schemat RFID czytnik pokazano na poniższym rysunku:

Rozważ główne cechy programu. Mikrokontroler wykorzystuje wbudowany modulator PWM do generowania fali prostokątnej 125 kHz na wyjściu PB0. Jeśli wyjście PB0 log. 0 (opadające zbocze impulsu), tranzystor T1 jest w stanie zamkniętym, a napięcie zasilania +5 V jest podawane na cewkę L1 przez rezystor R1. Zbocze narastające na wyjściu PB0 (log. 1) otwiera tranzystor T1, a górne wyjście cewki zgodnie z układem jest połączone z masą. W tym momencie cewka jest połączona równolegle z kondensatorem C2, tworząc generator LC (obwód oscylacyjny). Tranzystor przełącza się 125 000 razy na sekundę (125 kHz). W efekcie cewka generuje sygnał sinusoidalny o częstotliwości 125 kHz

Moduł czytnika generuje pole elektromagnetyczne, którego energia jest wykorzystywana do zasilania klucza RFID. Przenoszenie energii pomiędzy kluczem RFID a czytnikiem opiera się na zasadzie działania konwencjonalnego transformatora: uzwojenie pierwotne transformatora wytwarza indukcyjne pola elektromagnetyczne we wszystkich innych uzwojeniach. W naszym przypadku uzwojenie pierwotne to cewka czytnika, a uzwojenie wtórne to cewka klucza RFID. Elementy D1, C3 i R5 tworzą demodulator sygnału z modulacją amplitudy.

Wymiana danych między kluczem a czytnikiem

Proces wymiany danych pomiędzy kluczem RFID a czytnikiem jest bardzo prosty, ale przemyślany w najmniejszym szczególe. Czy klucz RFID powinien wysłać dziennik. 0, wówczas podłącza do swojego źródła zasilania określone „obciążenie”, co wymaga większej ilości energii przesyłanej przez czytnik. Spowoduje to niewielki spadek napięcia po stronie czytnika; to właśnie ten poziom jest postrzegany przez czytelnika jako dziennik. 0

Klucz RFID na ogół przesyła 64 bity danych w następującej kolejności (Rysunek 6):

1. Pierwsze 9 bitów (zawsze logiczne 1) to bity startu wskazujące początek wymiany danych.
2. 4 bity - najmniej znaczące bity numeru identyfikacyjnego użytkownika (D00 - D03).
3. 1 bit (P0) - bit parzystości poprzednich 4 bitów.
4. 4 bity to najbardziej znaczące bity numeru identyfikacyjnego użytkownika (D04 - D07).
5. 1 bit (P1) - bit parzystości poprzednich 4 bitów.
6. 4 bity - pierwsza część 32-bitowej numer seryjny Klucz RFID (D08 - D11).
7. 1 bit (P2) - bit parzystości poprzednich 4 bitów.
8. Następnie przesyłane są kolejne grupy 4 bitów numeru seryjnego klucza, każdy z bitem parzystości.
9. Następnie 4 bity bitów parzystości są przesyłane przez kolumny. Na przykład bit parzystości PC0 dla bitów D00, D04, D08, D12, D16, D20, D24, D28, D32 i D36.
10. 1 bit stopu.

Dane (sekwencja 64-bitowa), które przesyła klucz RFID.

Kontrola integralności danych jest wykonywana przez mikrokontroler poprzez obliczenie bitów parzystości dla każdego wiersza i kolumny oraz porównanie z otrzymanymi danymi z klucza RFID.

Konstrukcja cewki.

Bezramkowa cewka indukcyjna w czytniku o średnicy 120 mm jest nawinięta drutem o średnicy 0,5 mm i ma 58 zwojów, ale autor zaleca dodanie kolejnych 2 - 3 zwojów podczas nawijania. W celu poprawy wydajności cewki i zwiększenia odległości odczytu danych klucza RFID konieczna jest kalibracja obwodu oscylacyjnego. Jeśli po podłączeniu oscyloskopu do punktu połączenia R1 i L1 zobaczysz zniekształcone piki na ekranie urządzenia (Rysunek 7), oznacza to konieczność kalibracji cewki L1.

Zniekształcenie sygnału generowanego przez cewkę L1 wskazuje na konieczność kalibracji.

Kalibrację można przeprowadzić na dwa sposoby po włączeniu zasilania modułu.

1. Podłącz sondy oscyloskopowe do punktu połączenia R1 i L1 i zwiększając lub zmniejszając liczbę zwojów cewki L1 eliminuj zniekształcenia sygnału.
2. Jeśli nie masz oscyloskopu, to powoli zbliżaj klucz RFID do cewki, aż klucz zostanie rozpoznany, o czym świadczy sygnał dźwiękowy. Jeżeli klucz jest ustalany z odległości 2 cm, to należy dodać/usunąć kilka zwojów, a następnie ponownie sprawdzić z jakiej odległości klucz można pewnie odczytać. Dzięki kalibracji autor schematu uzyskał pewny odczyt klucza RFID od 3 cm.

Podczas programowania mikrokontrolera należy ustawić następującą konfigurację Fuse-bit: niski bajt 0x7A i wysoki bajt 0x1F (mikrokontroler działa z wbudowanego generatora zegara 9,6 MHz, dzielnik częstotliwości taktowania przez 8 jest wyłączony). Kod programu zajmuje 1024 bajty w pamięci mikrokontrolera - wykorzystywana jest cała dostępna pamięć mikrokontrolera ATtiny13. Dlatego w przyszłości przy rozszerzaniu funkcjonalności czytnika lepiej zastosować kolejny 8-pinowy mikrokontroler AVR, na przykład ATtiny85.

Pliki do pobrania:

Kod źródłowy programu mikrokontrolera (AVRStudio 6), firmware (.hex) i Schemat obwodu -

Ten projekt powstał na prośbę znajomego do zamontowania na drzwiach do magazynu. W przyszłości powstało jeszcze kilka na prośbę przyjaciół i znajomych. Projekt okazał się prosty i niezawodny. Pracujący to urządzenie w ten sposób: przechodzi tylko przez karty RFID, które zostały wcześniej wprowadzone do pamięci urządzenia.

Główne cechy kontrolera dostępu:

Karty RFID w formacie EMmarin 125kHz

Mikrokontroler ATtiny13

Ilość kart / breloków - 10.
Przycisk „OPEN” jest normalnie otwarty, zabezpieczony przed przyklejeniem.
Wyjście sterujące blokadą, wysokoprądowy tranzystor polowy, tryb pracy zatrzaskowej (włącza się tymczasowo).

Jedzenie - 12v.
Pobór w trybie czuwania - 35 mA.
Ilość kart dostępu/pilotów - 10 szt.
Długość komunikacji z przyciskiem „OPEN” to 10 metrów.
Typ wyjścia sterującego zamkiem - otwarty dren (tranzystor polowy o dużej mocy, prąd do 2A).

Schemat ideowy kontrolera kontroli dostępu na kartach RFID 125KHz (Em-Marin) dla 10 kart (na mikrokontrolerze ATtiny13):

Jeśli potrzebujesz sterować zamkiem elektromagnetycznym, musisz zainstalować przekaźnik wyjściowy z wymaganą grupą styków.

Wygląd zmontowanego walidatora RFID:

Instalowanie Fuse-bitów w PonyProg:

Obsługa urządzenia, pobierz wideo nagrane przez autora.
Ponadto jeden z czytelników zamieścił film ze zmontowanego urządzenia:

Instrukcja programowania

Tryb pracy - po doprowadzeniu 12V do sterownika dioda LED miga z częstotliwością 1Hz.
Tryb programowania - dioda LED miga 2 Hz.
Po naciśnięciu przycisku „OPEN” podczas otwierania zamka pojawia się seria krótkich dźwięków dźwiękowych.

Sygnały dźwiękowe

1 krótki dźwięk – karta lub pilot jest zapisana w pamięci kontrolera.
2 krótkie dźwięki – karta lub pilot jest już zapisana w pamięci kontrolera.
5 krótkich dźwięków - wyjście z trybu programowania.
1 długi dźwięk - pamięć karty została skasowana z kontrolera.
ciągły krótkie sygnały- pamięć kart/kluczy jest pełna, maksymalnie 10 szt. (wymaga wyłączenia zasilania sterownika).

Nagrywanie KARTY MASTER i czasu otwarcia zamka

1 - Wyłącz kontroler.
2 - Naciśnij przycisk „OPEN”
3 - Trzymając przycisk, podłącz zasilanie do kontrolera po 5 sekundach. kontroler "BEEPS", dioda LED będzie migać z częstotliwością 2 Hz.
4 - Zwolnij przycisk.
5 - Zbliż kartę lub breloczek do strefy odczytu, zabrzmi pojedynczy dźwięk, ZAPISANA jest karta Master lub brelok, a czas otwarcia zamka 1 sek.

6 - Trzymając kartę lub breloczek w obszarze odczytu – odczytujemy sygnały dźwiękowe. Ilość określa wymagany czas otwarcia zamka, skok 1 sek., ale nie więcej niż 32 sek.
7 - Wyłącz zasilanie kontrolera lub wstrzymaj na 30 sekund.

Kasowanie całej pamięci karty

1 - Tryb pracy.
2 - Wcisnąć przycisk „OPEN” i trzymając go zbliżyć do czytnika kartę lub brelok MASTER i przytrzymać, po 5 sekundach rozlegnie się długi sygnał dźwiękowy - pamięć kart / breloka została skasowana.
3 - Zwolnij przycisk, wyjmij kartę lub breloczek.

Dzisiejszy samouczek dotyczy wykorzystania czytnika RFID z Arduino do stworzenia prostego systemu blokującego, w prostych słowach- Zamek RFID.

RFID (ang. Radio Frequency IDentification, identyfikacja częstotliwości radiowej) to metoda automatycznej identyfikacji obiektów, w której dane przechowywane w tzw. transponderach, czyli tagach RFID, są odczytywane lub zapisywane za pomocą sygnałów radiowych. Każdy system RFID składa się z czytnika (czytnika, czytnika lub interrogatora) i transpondera (inaczej tag RFID, czasami używa się również określenia tag RFID).

Samouczek użyje tagu RFID z Arduino. urządzenie odczytuje unikalny identyfikator(UID) każdego tagu RFID, który umieszczamy obok czytnika i wyświetlamy na wyświetlaczu OLED. Jeżeli UID tagu jest równy predefiniowanej wartości, która jest zapisana w pamięci Arduino, na wyświetlaczu pojawi się komunikat „Unlocked”. Jeśli unikalny identyfikator nie jest zgodny z predefiniowaną wartością, komunikat „Odblokowany” nie pojawi się - patrz zdjęcie poniżej.

Zamek jest zamknięty

Zamek jest otwarty

Szczegóły potrzebne do stworzenia tego projektu:

• Czytnik RFID RC522
• Wyświetlacz OLED
• Deska do chleba
• przewody

Dodatkowe Szczegóły:

• Bateria (powerbank)

Całkowity koszt komponentów projektu wyniósł około 15 USD.

Krok 2: Czytnik RFID RC522

Każdy tag RFID posiada mały chip (na zdjęciu biała karta). Jeśli skierujesz latarkę na tę kartę RFID, zobaczysz mały chip i otaczającą go cewkę. Ten chip nie ma baterii do generowania energii. Otrzymuje zasilanie z czytnika bezprzewodowo za pomocą tej dużej cewki. Taką kartę RFID można odczytać z odległości do 20 mm.

Ten sam chip występuje w brelokach RFID.

Każdy tag RFID posiada unikalny numer, który go identyfikuje. To jest UID, który jest wyświetlany na wyświetlaczu OLED. Z wyjątkiem tego UID, każdy tag może przechowywać dane. Karta tego typu może przechowywać do 1000 danych. Imponujące, prawda? Ta funkcja nie będzie dziś używana. Dziś interesująca jest tylko identyfikacja konkretnej karty za pomocą jej UID. Czytnik RFID i te dwie karty RFID kosztują około 4 USD.

Krok 3 Wyświetlacz OLED

W samouczku zastosowano monitor OLED I2C o przekątnej 0,96 cala i rozdzielczości 128x64.

To bardzo dobry wyświetlacz do współpracy z Arduino. Jest to wyświetlacz OLED, a to oznacza, że ​​ma niski pobór mocy. Pobór mocy tego wyświetlacza wynosi około 10-20mA i zależy od liczby pikseli.

Wyświetlacz ma rozdzielczość 128 na 64 piksele i jest niewielki. Dostępne są dwie opcje wyświetlania. Jeden z nich jest monochromatyczny, a drugi, podobnie jak ten użyty w samouczku, może wyświetlać dwa kolory: żółty i niebieski. Górna część ekranu może być tylko żółta, a dolna niebieska.

Ten wyświetlacz OLED jest bardzo jasny i ma świetną i bardzo ładną bibliotekę, którą Adafruit opracował dla tego wyświetlacza. Oprócz tego wyświetlacz wykorzystuje interfejs I2C, dzięki czemu połączenie z Arduino jest niezwykle łatwe.

Wystarczy podłączyć dwa przewody z wyjątkiem Vcc i GND. Jeśli jesteś nowy w Arduino i chcesz użyć niedrogiego i prostego wyświetlacza w swoim projekcie, zacznij tutaj.

Krok 4: Łączenie wszystkich części