Эмулятор RFID на Arduino / Блог компании / Хабр

Аппаратное обеспечение

Как я уже сказал, эмулятор должен быть собран на доступных комплектующих, которые можно легко достать. Для начала рассмотрим схему эмулятора.

У нас есть колебательный контур, который мы будем замыкать в определённое время транзистором и таким образом в считывателе будет изменяться ток, и он будет получать передаваемые данные. Самым сложным для нас в этой связке остаётся настроенные на частоту 125 кГц колебательный контур.

И есть очень простое решение, откуда его можно взять. В продаже существует считыватель RFID-меток для Arduino RDM6300. Считыватель стоит сущие копейки, а у него в комплекте уже идёт антенна, а резонансный конденсатор уже распаян на плате. Таким образом, по сути считыватель нам нужен только для двух деталей: катушки и резонанстного конденсатора.

Считыватель RDM6300 и расположение резонансного конденсатора.

Я купил этот считыватель за какие-то копейки, которые несоизмеримы с трудами по намотке и настройке антенны. Самая сложная операция у нас — это отпаять данный конденсатор и припаять его на монтажную плату. Верю, что с ней справиться даже школьник младших классов.

Схема в сборе.

Ну и посмотрим крупным планом, как это всё выглядит. Я специально под конденсатор выделил отдельную платку, там он припаян прямо на монтажные иголки, которые вставлены в этот матрац.

Для того, чтобы проверять работу эмулятора, изначально я думал использовать тот же RDM6300 (купил их два). И даже по началу так и делал, но потом решил, что это как-то не серьёзно, одной Ардуиной отлаживать другую, и разорился на заводской считыватель.

Заводской считыватель.

Взводим таймер

Наиболее полно всю физику процесса и принцип работы я рассказал в

, поэтому настоятельно рекомендую с ней ознакомиться. Однако для понимания того, что я делаю немного освежу некоторые моменты.

Напомню, что у EM4102 используется схема Манчестерского кодирования. Когда идёт модуляция EM4102 протокола, время передачи одного бита может составлять 64, 32 или 16 периодов несущей частоты (125 кГц).

Проще говоря, при передаче одного бита, у нас меняется значение либо единицы на нуль (при передаче нуля), либо с нуля на единицу (при передаче единицы). Соответственно, если мы выбираем для передаче одного бита информации 64 периода несущей частоты, то для передачи “полубита” нам нужно будет 32 периода несущей частоты. Таким образом каждый полубит должен меняться с частотой:

f=125000/32 = 3906,25 Гц

Период этого “полубита” будет равен 256 мкс.

Теперь нам нужно посчитать таймер, чтобы он нам дёргал ногу с данной частотой. Но я стал так ленив, что открыв даташит и начав зевать, решил найти какое-то готовое решение. И оказалось, что есть готовые расчёты таймеров, только вбивай свои данные. Встречайте: калькулятор таймера для Ардуино.

Смотрите про коптеры:  Радиоуправляемый катер своими руками

Нам необходимо только забить частоту таймера 3906 Гц, и нам сразу сгенерируют готовый к использованию код. Ну не чудо ли!

Обратите внимание, что частоту я вводил целыми, а он её посчитал дробными и именно ту, которая нам и нужна. Код инициализации таймера у меня получился следующий:

void setupTimer1() {
  noInterrupts();
  // Clear registers
  TCCR1A = 0;
  TCCR1B = 0;
  TCNT1 = 0;

  // 3906.25 Hz (16000000/((4095 1)*1))
  OCR1A = 4095;
  // Prescaler 1
  TCCR1B |= (1 << CS10);
  // Output Compare Match A Interrupt Enable
  TIMSK1 |= (1 << OCIE1A);
  interrupts();
}

Гениально, просто, лаконично.

Вектор прерывания для вывода устроен тоже очень просто. Напоминаю, что нам необходимо делать переход с единицы на нуль в случае передачи нуля, и с нуля на единицу, в случае передачи единицы (смотрите рисунок для понимания). Поэтому смотрим, что мы сейчас передаём и в каком месте “полубита” находимся, постепенно считывая из массива data все данные.

ISR(TIMER1_COMPA_vect) {
        TCNT1=0;
	if (((data[byte_counter] << bit_counter)&0x80)==0x00) {
	    if (half==0) digitalWrite(ANTENNA, LOW);
	    if (half==1) digitalWrite(ANTENNA, HIGH);
	}
	else {
	    if (half==0) digitalWrite(ANTENNA, HIGH);
	    if (half==1) digitalWrite(ANTENNA, LOW);
	}
    
	half  ;
	if (half==2) {
	    half=0;
	    bit_counter  ;
	    if (bit_counter==8) {
	        bit_counter=0;
	        byte_counter=(byte_counter 1)%8;
		}
	}
}

Испытания

Как говориться, лучше один раз увидеть, чем тысячу раз прочитать. Специально для вас записал кино о работе этого эмулятора. Хотел его протестировать на реальном железе, и попробовать пробраться в офис с помощью Arduino, но с проклятой пандемией туда не пускают. Поэтому натурные испытания придётся смотреть на столе, в лабораторных условиях.

Перевод данных для передачи

Тут тоже следует освежить в памяти форматы данных, хранимые на карте. То, в каком виде они записаны. Давайте на живом примере.

Предположим у нас есть карта, но нет ридера. На карте написан номер 010,48351.

Реальная карта с номером 010, 48351.

Как этот номер нам перевести в тот серийный номер, который записан на карте? Достаточно просто. Вспоминаем формулу: переводим две части числа отдельно:

010d = 0xA
48351d = 0xBCDF

Итого, серийный номер у нас получается: 0xABCDF. Проверим его, считываем карточку считывателем (он читает в десятичном формате), получаем число:

0000703711

Переводим его любым калькулятором в хекс-формат и получаем снова: 0xABCDF.


Вроде пока просто, погодите, сейчас мозги придётся поднапрячь. Напомню формат данных, которые лежат на самой карте.

Проговорю словами:

  1. Вначале идут девять единиц заголовка.
  2. Младшие пол байта ID клиента.
  3. В конце бит чётности.
  4. Вторые пол байта ID клиента.
  5. Бит чётности.
  6. Младшие пол байта нулевого байта серийного номера.
  7. Бит чётности
  8. Старшие пол байта данных байта нулевого байта серийного номера.
  9. Точно так же все остальные данные, передаются ниблами и оканчиваются битом чётности
  10. Самое сложное. Теперь все эти 10 нибблов по вертикали точно так же вычисляется бит чётности (прямо как в таблице).
  11. Завершает всё это безобразие стоп бит, который равен всегда нулю.
Смотрите про коптеры:  Мощные двигатели для квадрокоптеров-Купить -

Итого у нас получается 64 бита данных (это из пяти байт!). В качестве ремарки, мой считыватель не читает ID-клиента, и я его принимаю равным нулю.

Что такое бит чётности? Это количество единиц в посылке: если оно чётное, то бит чётности равен нулю, если нет, то единице. Проще всего рассчитать его, просто обычным XOR.

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

Тестовая программа перевода серийника в данные

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

#define BYTE_TO_BINARY_PATTERN "%c%c%c%c%c%c%c%c"
#define BYTE_TO_BINARY(byte)  
  (byte & 0x80 ? '1' : '0'), 
  (byte & 0x40 ? '1' : '0'), 
  (byte & 0x20 ? '1' : '0'), 
  (byte & 0x10 ? '1' : '0'), 
  (byte & 0x08 ? '1' : '0'), 
  (byte & 0x04 ? '1' : '0'), 
  (byte & 0x02 ? '1' : '0'), 
  (byte & 0x01 ? '1' : '0') 

#define NYBBLE_TO_BINARY_PATTERN "%c%c%c%c"
#define NYBBLE_TO_BINARY(byte)  
	(byte & 0x08 ? '1' : '0'), 
	(byte & 0x04 ? '1' : '0'), 
	(byte & 0x02 ? '1' : '0'), 
	(byte & 0x01 ? '1' : '0') 


int main() {
	//unsigned long long card_id = 0x00000ABCDF;
	//uint64_t card_id = 0x00000ABCDF;
	uint64_t card_id = (uint64_t)3604000;
	uint64_t data_card_ul = 0x1FFF; //first 9 bit as 1
	int32_t i;
	uint8_t tmp_nybble;
	uint8_t column_parity_bits = 0;
	printf("card_id = 0x%lXn", card_id);
	for (i = 9; i >= 0; i--) { //5 bytes = 10 nybbles
		tmp_nybble = (uint8_t) (0x0f & (card_id >> i*4));
		data_card_ul = (data_card_ul << 4) | tmp_nybble;
		printf("0xX", (int) tmp_nybble);
		printf("t"NYBBLE_TO_BINARY_PATTERN, NYBBLE_TO_BINARY(tmp_nybble));
		printf("t %dn", (tmp_nybble >> 3 & 0x01) ^ (tmp_nybble >> 2 & 0x01) ^
			(tmp_nybble >> 1 & 0x01) ^ (tmp_nybble  & 0x01));
		data_card_ul = (data_card_ul << 1) | ((tmp_nybble >> 3 & 0x01) ^ (tmp_nybble >> 2 & 0x01) ^
			(tmp_nybble >> 1 & 0x01) ^ (tmp_nybble  & 0x01));
		column_parity_bits ^= tmp_nybble;
	}
	data_card_ul = (data_card_ul << 4) | column_parity_bits;
	data_card_ul = (data_card_ul << 1); //1 stop bit = 0
	printf("t"NYBBLE_TO_BINARY_PATTERN"n", NYBBLE_TO_BINARY(column_parity_bits));
	printf("data_card_ul = 0x%lXn", data_card_ul);
	
	for (i = 7; i >= 0; i--) {
		printf("0xX,", (int) (0xFF & (data_card_ul >> i * 8)));
	}
	printf("n");
	return 0;
}

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

card_id

— это серийный номер карты (о котором мы говорили выше).

Первый столбец — это ниблы, второй — их битовое представление, третий — это бит чётности. Третья строка снизу — это биты чётности всех ниблов. Как я уже сказал, они рассчитываются просто операцией XOR.

Смотрите про коптеры:  Лучший симулятор квадрокоптера | Учимся гонять на коптере | RCDetails Blog

Протестировав расчёты, сверив из визуально, я проверил получившиеся данные в программе на Arduino (последняя строка специально для вставки в код). Всё отработало отлично. В результате наброска этой программы, я получил готовую функцию пересчёта. Раньше, расчёты битов были чужими программами на компе и мне не нравилась их монструозная реализация. Таким образом функция пересчёта серийного номера в формат передачи выглядит так:


#define CARD_ID 0xABCDF

uint8_t data[8];

void data_card_ul() {
  uint64_t card_id = (uint64_t)CARD_ID;
  uint64_t data_card_ul = (uint64_t)0x1FFF; //first 9 bit as 1
  int32_t i;
  uint8_t tmp_nybble;
  uint8_t column_parity_bits = 0;
  for (i = 9; i >= 0; i--) { //5 bytes = 10 nybbles
    tmp_nybble = (uint8_t) (0x0f & (card_id >> i*4));
    data_card_ul = (data_card_ul << 4) | tmp_nybble;
    data_card_ul = (data_card_ul << 1) | ((tmp_nybble >> 3 & 0x01) ^ (tmp_nybble >> 2 & 0x01) ^
      (tmp_nybble >> 1 & 0x01) ^ (tmp_nybble  & 0x01));
    column_parity_bits ^= tmp_nybble;
  }
  data_card_ul = (data_card_ul << 4) | column_parity_bits;
  data_card_ul = (data_card_ul << 1); //1 stop bit = 0
  for (i = 0; i < 8; i  ) {
    data[i] = (uint8_t)(0xFF & (data_card_ul >> (7 - i) * 8));
  }
}

Всё, можно переходить к полевым испытаниям. Исходный код проекта обитает

Icm-20608-g [not recommended for new designs]

The ICM-20608-G is the latest 6-axis device offered by InvenSense for the mass market. Compared to previous 6-axis devices, the ICM-20608-G offers lower power consumption, lower noise, and a thinner package. The ICM-20608-G offers a duty-cycled operation mode for the gyroscope, that reduces gyroscope power consumption by half or more (depending on ODR) compared to earlier 6-axis devices. It also provides about 20% lower noise than previous devices, and about 17% thinner package compared to previous devices.

The ICM-20608-G is a 6-axis MotionTracking device that combines a 3-axis gyroscope, and a 3-axis accelerometer in a small, 3 mm x 3 mm x 0.75 mm (16-pin LGA) package. It also features a 512-byte FIFO that can lower the traffic on the serial bus interface, and reduce power consumption by allowing the system processor to burst read sensor data, entering into a low-power mode.

Выводы

Очень надеюсь, что подобные статьи подстегнуть новичков изучать программирование и электронику. А так же они поспособствуют уходу с рынка такого типа карт, как самых незащищённых и небезопасных, поскольку теперь их может скопировать и эмулировать даже ребёнок.

Выражаю благодарность Michal Krumnikl за его терпение много-много лет назад, когда он мне по icq разъяснял работу подобного эмулятора, а так же помощь с разработкой кода. В некотором смысле это его идеи и наработки 13-ти летней давности.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

Adblock
detector