liz/flipperzero-firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[FL-1449] Indala reading and writing (#616)

Browse Source 
* Rfid: indala 40134 validation and decoding
* Rfid: show indala info
* Rfid: decoder to output comparator signal on gpio pins
* Rfid: working indala 40134 decoder
* HAL: added function to change rfid timer parameters on the fly
* RFID: Indala reading, card detection, card verification
* Rfid: indala writing
This commit is contained in:
SG
2021-08-02 08:11:18 +10:00
committed by GitHub
parent fb80f9537f
commit 6926cf8b7e
16 changed files with 406 additions and 239 deletions
Download Patch File Download Diff File Expand all files Collapse all files

190
applications/lfrfid/helpers/decoder-indala.cpp
View File

@@ -2,18 +2,24 @@
#include <api-hal.h>
constexpr uint32_t clocks_in_us = 64;
constexpr uint32_t min_time_us = 25 * clocks_in_us;
constexpr uint32_t mid_time_us = 45 * clocks_in_us;
constexpr uint32_t max_time_us = 90 * clocks_in_us;
constexpr uint32_t us_per_bit = 255;
bool DecoderIndala::read(uint8_t* data, uint8_t data_size) {
bool result = false;
if(ready) {
result = true;
printf("IND %02X %02X %02X\r\n", facility, (uint8_t)(number >> 8), (uint8_t)number);
ready = false;
if(cursed_data_valid) {
indala.decode(
reinterpret_cast<const uint8_t*>(&cursed_raw_data),
sizeof(uint64_t),
data,
data_size);
} else {
indala.decode(
reinterpret_cast<const uint8_t*>(&raw_data), sizeof(uint64_t), data, data_size);
}
reset_state();
}
return result;
@@ -22,149 +28,49 @@ bool DecoderIndala::read(uint8_t* data, uint8_t data_size) {
void DecoderIndala::process_front(bool polarity, uint32_t time) {
if(ready) return;
if(polarity == false) {
last_pulse_time = time;
} else {
last_pulse_time += time;
pulse_count++;
process_internal(polarity, time, &raw_data);
if(ready) return;
if(last_pulse_time > min_time_us && last_pulse_time < max_time_us) {
if(last_pulse_time > mid_time_us) {
bool last_data = !(readed_data & 1);
pulse_count = 0;
readed_data = (readed_data << 1) | last_data;
verify();
} else if((pulse_count % 16) == 0) {
bool last_data = readed_data & 1;
pulse_count = 0;
readed_data = (readed_data << 1) | last_data;
verify();
if(polarity) {
time = time + 110;
} else {
time = time - 110;
}
process_internal(!polarity, time, &cursed_raw_data);
if(ready) {
cursed_data_valid = true;
}
}
void DecoderIndala::process_internal(bool polarity, uint32_t time, uint64_t* data) {
time /= clocks_in_us;
time += (us_per_bit / 2);
uint32_t bit_count = (time / us_per_bit);
if(bit_count < 64) {
for(uint32_t i = 0; i < bit_count; i++) {
*data = (*data << 1) | polarity;
if((*data >> 32) == 0xa0000000ULL) {
if(indala.can_be_decoded(
reinterpret_cast<const uint8_t*>(data), sizeof(uint64_t))) {
ready = true;
break;
}
}
}
}
}
DecoderIndala::DecoderIndala() {
reset_state();
}
void DecoderIndala::reset_state() {
}
void DecoderIndala::verify() {
// verify inverse
readed_data = ~readed_data;
verify_inner();
// verify normal
readed_data = ~readed_data;
verify_inner();
}
typedef union {
uint64_t raw;
struct __attribute__((packed)) {
uint8_t static0 : 3;
uint8_t checksum : 2;
uint8_t static1 : 2;
uint8_t y14 : 1;
uint8_t x8 : 1;
uint8_t x1 : 1;
uint8_t y13 : 1;
uint8_t static2 : 1;
uint8_t y12 : 1;
uint8_t x6 : 1;
uint8_t y5 : 1;
uint8_t y8 : 1;
uint8_t y15 : 1;
uint8_t x2 : 1;
uint8_t x5 : 1;
uint8_t x4 : 1;
uint8_t y9 : 1;
uint8_t y2 : 1;
uint8_t x3 : 1;
uint8_t y3 : 1;
uint8_t y1 : 1;
uint8_t y16 : 1;
uint8_t y4 : 1;
uint8_t x7 : 1;
uint8_t p2 : 1;
uint8_t y11 : 1;
uint8_t y6 : 1;
uint8_t y7 : 1;
uint8_t p1 : 1;
uint8_t y10 : 1;
uint32_t preamble : 30;
};
} IndalaFormat;
void DecoderIndala::verify_inner() {
IndalaFormat id;
id.raw = readed_data;
// preamble
//if((data >> 34) != 0b000000000000000000000000000001) return;
if(id.preamble != 1) return;
// static data bits
//if((data & 0b100001100111) != 0b101) return;
if(id.static2 != 0 && id.static1 != 0 && id.static0 != 0b101) return;
// Indala checksum
uint8_t sum_to_check = id.y2 + id.y4 + id.y7 + id.y8 + id.y10 + id.y11 + id.y14 + id.y16;
if(sum_to_check % 2 == 0) {
if(id.checksum != 0b10) return;
} else {
if(id.checksum != 0b01) return;
}
// read facility number
facility = (id.x1 << 7) + (id.x2 << 6) + (id.x3 << 5) + (id.x4 << 4) + (id.x5 << 3) +
(id.x6 << 2) + (id.x7 << 1) + (id.x8 << 0);
// read serial number
number = (id.y1 << 15) + (id.y2 << 14) + (id.y3 << 13) + (id.y4 << 12) + (id.y5 << 11) +
(id.y6 << 10) + (id.y7 << 9) + (id.y8 << 8) + (id.y9 << 7) + (id.y10 << 6) +
(id.y11 << 5) + (id.y12 << 4) + (id.y13 << 3) + (id.y14 << 2) + (id.y15 << 1) +
(id.y16 << 0);
// Wiegand checksum left
sum_to_check = 0;
for(int8_t i = 0; i < 8; i--) {
if((facility >> i) & 1) {
sum_to_check += 1;
}
}
for(int8_t i = 0; i < 4; i--) {
if((number >> i) & 1) {
sum_to_check += 1;
}
}
if(id.p1) {
sum_to_check += 1;
}
if((sum_to_check % 2) == 1) return;
// Wiegand checksum right
sum_to_check = 0;
for(int8_t i = 0; i < 12; i--) {
if((number >> (i + 4)) & 1) {
sum_to_check += 1;
}
}
if(id.p2) {
sum_to_check += 1;
}
if((sum_to_check % 2) != 1) return;
ready = true;
}
raw_data = 0;
cursed_raw_data = 0;
ready = false;
cursed_data_valid = false;
}