RFID и Arduino: модуль RC522, метки и чтение номера

Что вообще делает RFID-модуль

Внутри карты нет ни батарейки, ни кнопки. Есть микросхема размером с песчинку и несколько витков провода по краю пластика — антенна. Считыватель непрерывно создаёт вокруг себя переменное магнитное поле. Когда карта попадает в это поле, в её витках наводится ток — метка оживает ровно на то время, пока её держат рядом.

Дальше начинается разговор. Считыватель спрашивает, метка отвечает — но отвечает хитро: собственного передатчика у неё тоже нет, поэтому она то нагружает, то отпускает свою антенну, и считыватель чувствует эти лёгкие «подмигивания» в собственном поле. Поэтому дальность у такой связи всегда маленькая: это не радио на километр, а связь двух катушек, лежащих почти вплотную.

Отсюда сразу два практических вывода. Первый: «увеличить дальность» у RC522 по-настоящему нельзя — можно подкрутить усиление приёмника и добавить сантиметр, но метр не получится. Второй: любая помеха между модулем и меткой мешает. Металлический стол под платой, толстый корпус, фольгированная наклейка — всё это отбирает у метки энергию.

Главный вопрос: увидит ли RC522 ваш ключ

Половина неудач с RFID случается ещё до первой строчки кода — человек покупает модуль, чтобы «прочитать ключ от подъезда», и получает молчание. Дело не в модуле. Словом «ключ» называют три совершенно разные вещи, и переходов между ними не существует.

Как понять, что у вас. Металлическая таблетка — это контакт, ей нужен не считыватель, а два провода. Пластиковая капля или тонкая круглая метка — нужно узнавать: в старых домофонах это почти всегда 125 кГц, в новых встречаются и карты 13,56 МГц. Внешне они неразличимы, поэтому надёжный способ один: посмотреть модель домофона или спросить в обслуживающей организации. Пропуск на работу и транспортная карта — почти всегда 13,56 МГц.

Что на самом модуле

Красная плата RC522 — это микросхема NXP MFRC522, кварц на 27,12 МГц (частота поля получается делением пополам — те самые 13,56 МГц) и рамка антенны, занимающая половину платы. Сбоку — планка из восьми контактов, которую почти всегда нужно припаять самому: в пакетике она лежит отдельно, а просто вставленные в отверстия штырьки контакта не дают. Это причина номер один всех «модуль не работает».

Две подписи сбивают с толку. SDA здесь — не линия шины I2C, а обычный вывод выбора устройства на шине SPI: искать рядом с ним SCL бесполезно. А в характеристиках модуля перечислены сразу три интерфейса — SPI, UART и I2C: это умеет сама микросхема, но на гребёнку выведен только SPI, поэтому подключать модуль нужно именно к нему. Про саму шину — в соседнем разборе про модули и способы подключения.

Подключение: выводы зависят от платы

Проводов семь, и на разных платах они идут на разные выводы. Выберите свою плату — схема перестроится.

Питание — только 3,3 вольта. Даташит разрешает микросхеме от 2,5 до 3,6 В, а 4 В названы предельным значением, за которым начинается разрушение. Пять вольт на вывод питания — это не «с запасом», это конец модуля. При этом сигнальные провода у Uno и Nano пятивольтовые, и формально они тоже выше нормы: предел входа — питание плюс полвольта, то есть около 3,8 В. В учебной схеме такое соединение работает у миллионов людей, но если вы делаете изделие, между платой и модулем ставят преобразователь уровней, а лучше берут плату на 3,3 В.

Ток. Когда поле включено, микросхема по даташиту берёт до 100 мА, в типовом режиме — десятки миллиампер. Вывод 3.3V у Uno рассчитан на 50 мА, и обычно модулю этого хватает; а вот у недорогих Nano этот вывод намного слабее, и как раз там появляются «метка читается через раз» и перезагрузки платы. Лечится отдельным стабилизатором на 3,3 В и конденсатором рядом с модулем.

Первый скетч: номер метки

Библиотека называется MFRC522 — она есть в каталоге библиотек и ставится в два клика. Скетч ниже печатает номер метки и её тип. Строка с версией в самом начале — бесплатная проверка связи: если там 0x91 или 0x92, модуль отвечает.

// Читаем номер метки модулем RC522.
// Схема (Arduino Uno): SDA - 10, SCK - 13, MOSI - 11, MISO - 12,
// RST - 9, GND - GND, а питание модуля - ТОЛЬКО с вывода 3.3V.
#include <SPI.h>       // шина SPI: по ней плата разговаривает с модулем
#include <MFRC522.h>   // библиотека модуля RC522

const uint8_t PIN_SDA = 10;   // выбор устройства на шине, он же SS
const uint8_t PIN_RST = 9;    // сброс модуля

MFRC522 reader(PIN_SDA, PIN_RST);

void setup() {
  Serial.begin(9600);
  SPI.begin();                          // без этой строки модуль будет молчать
  reader.PCD_Init();
  reader.PCD_DumpVersionToSerial();     // версия в мониторе = связь есть
  Serial.println(F("Поднесите метку к модулю"));
}

void loop() {
  if (!reader.PICC_IsNewCardPresent()) return;   // метки рядом нет
  if (!reader.PICC_ReadCardSerial()) return;     // номер не прочитался

  Serial.print(F("Номер метки: "));
  for (uint8_t i = 0; i < reader.uid.size; i++) {
    if (reader.uid.uidByte[i] < 0x10) Serial.print('0');
    Serial.print(reader.uid.uidByte[i], HEX);
    Serial.print(' ');
  }
  Serial.println();

  MFRC522::PICC_Type type = reader.PICC_GetType(reader.uid.sak);
  Serial.print(F("Тип метки: "));
  Serial.println(reader.PICC_GetTypeName(type));

  reader.PICC_HaltA();   // отпускаем метку, иначе номер печатается без конца
}

В мониторе порта появится что-то вроде Firmware Version: 0x92 = v2.0, а после поднесения карты — Номер метки: 04 A3 19 7C и Тип метки: MIFARE 1KB. Номер может быть из четырёх или из семи байт — это нормально, длину сообщает сама метка.

Ничего не читается: разбор по симптомам

Сначала выясните главное: модуль вообще отвечает плате или нет. Этот короткий скетч отвечает ровно на этот вопрос и не требует никакой метки.

// Проверка связи с модулем: отвечает он или нет.
// Запускать, когда метки не читаются и непонятно, кто виноват.
#include <SPI.h>
#include <MFRC522.h>

const uint8_t PIN_SDA = 10;
const uint8_t PIN_RST = 9;

MFRC522 reader(PIN_SDA, PIN_RST);

void setup() {
  Serial.begin(9600);
  SPI.begin();
  reader.PCD_Init();
  delay(50);   // даём модулю проснуться после сброса

  uint8_t version = reader.PCD_ReadRegister(MFRC522::VersionReg);
  Serial.print(F("Регистр версии: 0x"));
  Serial.println(version, HEX);

  if (version == 0x00 || version == 0xFF) {
    Serial.println(F("Связи нет совсем: питание 3.3 В, провода SPI, пайка"));
  } else if (version == 0x91 || version == 0x92) {
    Serial.println(F("Отвечает настоящий MFRC522, можно нести метку"));
  } else {
    Serial.println(F("Отвечает, но чип не фирменный: дальность может быть меньше"));
  }
}

void loop() {
}

Значения 0x00 и 0xFF в даташите NXP не описаны вообще — их печатает не модуль, а тишина на шине: провод оборван, питания нет, гребёнка не пропаяна или в скетче забыт SPI.begin(). Дальше — таблица по симптомам.

О чём модуль разговаривает с меткой

Полсекунды у считывателя — это не одно действие, а короткий диалог по правилам стандарта. Пройдите его по шагам: станет понятно, откуда берётся номер, зачем нужна антиколлизия и в какой момент вообще появляется защита.

Обратите внимание на четвёртый шаг. Номер метки звучит в эфире открыто, до всякой проверки ключей — так устроен сам стандарт, иначе считыватель не смог бы отличить две карты друг от друга. Из этого следует главное правило всех проектов с картами: номер метки — это имя, а не пароль. Он прекрасно подходит, чтобы узнать «кто пришёл», и совершенно не подходит, чтобы решать «пускать ли внутрь» там, где есть чего терять.

Что лежит внутри карты

Самая распространённая метка — MIFARE Classic на 1 килобайт. Килобайт звучит солидно, но своих данных туда влезает заметно меньше: часть памяти занята заводским номером и ключами.

Память нарезана на 16 секторов, в каждом четыре блока по 16 байт. Последний блок сектора — служебный: в нём лежат два ключа и права доступа. Самый первый блок всей карты записан на заводе и защищён от записи. Итого под ваши данные остаётся 47 блоков — 752 байта.

Чтобы прочитать или записать блок, нужно сначала предъявить ключ сектора. У новой метки оба ключа заводские: шесть байт FF. Скетч ниже пишет в блок 4 короткую строку и тут же читает её обратно.

// Пишем в карту своё и читаем обратно: сектор 1, блок 4.
// Блок 0 и последний блок каждого сектора не трогаем: там заводской
// номер и ключи, а испорченный трейлер убивает сектор навсегда.
#include <SPI.h>
#include <MFRC522.h>

const uint8_t PIN_SDA = 10;
const uint8_t PIN_RST = 9;
const uint8_t BLOCK = 4;              // первый блок сектора 1
const char TEXT[] = "TREMA IDE";      // не длиннее 16 знаков

MFRC522 reader(PIN_SDA, PIN_RST);
MFRC522::MIFARE_Key key;

void setup() {
  Serial.begin(9600);
  SPI.begin();
  reader.PCD_Init();
  for (uint8_t i = 0; i < 6; i++) key.keyByte[i] = 0xFF;   // заводской ключ
  Serial.println(F("Поднесите карту MIFARE Classic"));
}

void loop() {
  if (!reader.PICC_IsNewCardPresent()) return;
  if (!reader.PICC_ReadCardSerial()) return;

  MFRC522::StatusCode status = reader.PCD_Authenticate(
    MFRC522::PICC_CMD_MF_AUTH_KEY_A, BLOCK, &key, &(reader.uid));
  if (status != MFRC522::STATUS_OK) {
    Serial.print(F("Ключ не подошёл: "));
    Serial.println(reader.GetStatusCodeName(status));
    reader.PICC_HaltA();
    reader.PCD_StopCrypto1();
    return;
  }

  uint8_t data[16];                     // в блок уходит ровно 16 байт
  for (uint8_t i = 0; i < 16; i++) {
    data[i] = i < strlen(TEXT) ? TEXT[i] : 0;
  }
  status = reader.MIFARE_Write(BLOCK, data, 16);
  Serial.println(status == MFRC522::STATUS_OK ? F("Записано") : F("Записать не вышло"));

  uint8_t buffer[18];                   // 16 байт данных плюс 2 байта проверки
  uint8_t size = sizeof(buffer);
  status = reader.MIFARE_Read(BLOCK, buffer, &size);
  if (status == MFRC522::STATUS_OK) {
    Serial.print(F("В блоке лежит: "));
    for (uint8_t i = 0; i < 16; i++) {
      Serial.print(buffer[i] == 0 ? ' ' : (char)buffer[i]);
    }
    Serial.println();
  }

  reader.PICC_HaltA();        // отпускаем карту
  reader.PCD_StopCrypto1();   // без этой строки следующая карта не прочитается
}

Три вещи, о которые спотыкаются все. Буфер для чтения должен быть на 18 байт, а не на 16: вместе с данными приходят два байта проверки. Записывается всегда ровно 16 байт — короткую строку надо дополнять нулями. И, самое важное, не трогайте служебный блок сектора: одна неверная комбинация прав доступа блокирует сектор необратимо, восстановить его нельзя ничем.

Свой список меток

Дальше обычно хочется, чтобы «свои» метки что-то включали. Самый простой вариант — список номеров прямо в программе: понятно, надёжно, но каждую новую метку приходится вписывать и заливать скетч заново.

// Свои метки открывают замок, чужие - нет.
// ВАЖНО: номер метки передаётся открыто, до всякой защиты. Это
// учебная модель замка, а не система безопасности.
#include <SPI.h>
#include <MFRC522.h>

const uint8_t PIN_SDA = 10;
const uint8_t PIN_RST = 9;
const uint8_t PIN_RELAY = 4;     // модуль реле включается низким уровнем
const uint16_t OPEN_MS = 2000;   // сколько держим замок открытым

MFRC522 reader(PIN_SDA, PIN_RST);

// Впишите сюда номера своих меток - их печатает первый скетч.
const uint8_t KNOWN_COUNT = 2;
const uint8_t KNOWN[KNOWN_COUNT][4] = {
  { 0xDE, 0xAD, 0xBE, 0xEF },
  { 0x12, 0x34, 0x56, 0x78 }
};

bool isKnown(const MFRC522::Uid &uid) {
  if (uid.size != 4) return false;         // здесь разбираем только 4 байта
  for (uint8_t card = 0; card < KNOWN_COUNT; card++) {
    bool same = true;
    for (uint8_t i = 0; i < 4; i++) {
      if (uid.uidByte[i] != KNOWN[card][i]) same = false;
    }
    if (same) return true;
  }
  return false;
}

void setup() {
  Serial.begin(9600);
  pinMode(PIN_RELAY, OUTPUT);
  digitalWrite(PIN_RELAY, HIGH);   // реле выключено
  SPI.begin();
  reader.PCD_Init();
}

void loop() {
  if (!reader.PICC_IsNewCardPresent()) return;
  if (!reader.PICC_ReadCardSerial()) return;

  if (isKnown(reader.uid)) {
    Serial.println(F("Метка своя - открываю"));
    digitalWrite(PIN_RELAY, LOW);
    delay(OPEN_MS);
    digitalWrite(PIN_RELAY, HIGH);
  } else {
    Serial.println(F("Чужая метка"));
  }

  reader.PICC_HaltA();
}

Взрослее — хранить список в EEPROM: это память, которая переживает выключение питания. У ATmega328P её ровно 1 килобайт, ячейка выдерживает не менее 100 000 перезаписей. Четырёхбайтные номера влезут туда парой сотен штук — на класс или на семью хватит с запасом. В скетче ниже первая приложенная метка становится мастер-меткой: ею включают режим добавления, а следующая метка попадает в список.

// Список своих меток живёт в EEPROM и переживает выключение.
// Первая приложенная метка становится мастер-меткой: ею включают
// режим добавления, следующая метка попадает в список.
#include <SPI.h>
#include <MFRC522.h>
#include <EEPROM.h>

const uint8_t PIN_SDA = 10;
const uint8_t PIN_RST = 9;
const uint8_t PIN_LED = 5;

const uint8_t ADDR_MAGIC = 0;    // признак «список уже заведён»
const uint8_t ADDR_COUNT = 1;    // сколько меток в списке
const uint8_t ADDR_MASTER = 2;   // мастер-метка, 4 байта
const uint8_t ADDR_LIST = 6;     // дальше по 4 байта на метку
const uint8_t MAGIC = 0xA5;
const uint8_t MAX_CARDS = 20;
const unsigned long ADD_WINDOW = 10000;   // окно добавления, мс

MFRC522 reader(PIN_SDA, PIN_RST);
bool addMode = false;
unsigned long addUntil = 0;

void readUid(uint16_t addr, uint8_t *out) {
  for (uint8_t i = 0; i < 4; i++) out[i] = EEPROM.read(addr + i);
}

bool sameUid(const uint8_t *a, const uint8_t *b) {
  for (uint8_t i = 0; i < 4; i++) {
    if (a[i] != b[i]) return false;
  }
  return true;
}

int8_t findCard(const uint8_t *uid) {
  uint8_t count = EEPROM.read(ADDR_COUNT);
  uint8_t stored[4];
  for (uint8_t i = 0; i < count; i++) {
    readUid(ADDR_LIST + i * 4, stored);
    if (sameUid(stored, uid)) return i;
  }
  return -1;
}

void addCard(const uint8_t *uid) {
  uint8_t count = EEPROM.read(ADDR_COUNT);
  if (count >= MAX_CARDS) {
    Serial.println(F("Список полон"));
    return;
  }
  // update пишет ячейку только при изменении - бережём ресурс памяти
  for (uint8_t i = 0; i < 4; i++) EEPROM.update(ADDR_LIST + count * 4 + i, uid[i]);
  EEPROM.update(ADDR_COUNT, count + 1);
  Serial.println(F("Метка добавлена"));
}

void setup() {
  Serial.begin(9600);
  pinMode(PIN_LED, OUTPUT);
  SPI.begin();
  reader.PCD_Init();

  if (EEPROM.read(ADDR_MAGIC) != MAGIC) {
    EEPROM.update(ADDR_COUNT, 0);
    Serial.println(F("Список пуст: первая метка станет мастер-меткой"));
  } else {
    Serial.print(F("Меток в списке: "));
    Serial.println(EEPROM.read(ADDR_COUNT));
  }
}

void loop() {
  if (addMode && millis() > addUntil) {
    addMode = false;
    digitalWrite(PIN_LED, LOW);
    Serial.println(F("Окно добавления закрылось"));
  }

  if (!reader.PICC_IsNewCardPresent()) return;
  if (!reader.PICC_ReadCardSerial()) return;

  if (reader.uid.size != 4) {
    Serial.println(F("Пример рассчитан на метки с номером из 4 байт"));
    reader.PICC_HaltA();
    return;
  }

  uint8_t uid[4];
  for (uint8_t i = 0; i < 4; i++) uid[i] = reader.uid.uidByte[i];

  if (EEPROM.read(ADDR_MAGIC) != MAGIC) {
    for (uint8_t i = 0; i < 4; i++) EEPROM.update(ADDR_MASTER + i, uid[i]);
    EEPROM.update(ADDR_MAGIC, MAGIC);
    Serial.println(F("Мастер-метка запомнена"));
    reader.PICC_HaltA();
    return;
  }

  uint8_t master[4];
  readUid(ADDR_MASTER, master);

  if (sameUid(master, uid)) {
    addMode = !addMode;
    addUntil = millis() + ADD_WINDOW;
    digitalWrite(PIN_LED, addMode ? HIGH : LOW);
    Serial.println(addMode ? F("Приложите новую метку") : F("Добавление отменено"));
  } else if (addMode) {
    if (findCard(uid) < 0) {
      addCard(uid);
    } else {
      Serial.println(F("Такая метка уже есть"));
    }
    addMode = false;
    digitalWrite(PIN_LED, LOW);
  } else if (findCard(uid) >= 0) {
    Serial.println(F("Метка своя - открываю"));
    digitalWrite(PIN_LED, HIGH);
    delay(1500);
    digitalWrite(PIN_LED, LOW);
  } else {
    Serial.println(F("Чужая метка"));
  }

  reader.PICC_HaltA();
}

Здесь важна одна тонкость: запись ведётся через update, а не write — так ячейка перезаписывается только при настоящем изменении и живёт дольше. И помните, что обычная заливка скетча EEPROM не трогает, а вот операция «записать загрузчик» стирает её целиком. Подробнее про виды памяти платы — в разборе «Память Arduino».

Замок: чем управлять и как не сжечь плату

Электрозамок или защёлка — это уже силовая нагрузка. Соленоид на 12 вольт берёт больше половины ампера, катушка обычного реле — около 70 мА, а вывод платы рассчитан на 20. Поэтому между Arduino и замком всегда стоит посредник: модуль реле с оптопарой или силовой ключ. Питание замка — отдельное, от своего источника, и общий провод у него с платой один.

Две ловушки, о которых редко пишут. Первая: недорогие модули реле включаются низким уровнем, а вывод платы в первые миллисекунды после сброса ещё не настроен как выход — замок может дёрнуться при каждом включении питания. Первой же строкой в setup() ставьте вывод в неактивное состояние. Вторая: электромагнитные защёлки не рассчитаны на длительное удержание — у типовых замков это 3–10 секунд подряд. Схему «пока карта приложена, замок открыт» так строить нельзя, нужен таймер на секунду-две, как в скетче выше.

Если управлять нужно не замком, а мотором или приводом — это соседняя тема, она разобрана в статье про моторы и драйвер L298N.

Честно про защиту

Проект «дверь открывается по карте» — прекрасное учебное задание и плохая система безопасности, и важно понимать почему. Номер метки передаётся открыто, до всякой проверки. Шифр, которым закрыта память MIFARE Classic, исследователи публично разобрали ещё в 2008 году: ключ восстанавливается меньше чем за секунду на обычном компьютере. Сами разработчики библиотеки прямо предупреждают, что использовать номер карты как удостоверение личности в системах доступа нельзя.

Это не повод не делать проект — это повод понимать его границы. Шкафчик в кабинете информатики, отметка присутствия на уроке, «своя» карта для запуска станка, игровой квест с картами-ключами — отличные применения. Настоящая входная дверь, сейф или касса — нет.

Что купить

Главное правило покупки: смотрите на частоту в характеристиках, а не в названии. Метка и считыватель должны быть из одного мира — 13,56 МГц или 125 кГц.