flipperzero-firmware/lib/one_wire/ibutton/protocols/protocol_cyfral.c

344 lines
9.8 KiB
C
Raw Normal View History

[FL-2529][FL-1628] New LF-RFID subsystem (#1601) * Makefile: unit tests pack * RFID: pulse joiner and its unit test * Move pulse protocol helpers to appropriate place * Drop pulse_joiner tests * Generic protocol, protocols dictionary, unit test * Protocol dict unit test * iButton: protocols dictionary * Lib: varint * Lib: profiler * Unit test: varint * rfid: worker mockup * LFRFID: em4100 unit test * Storage: file_exist function * rfid: fsk osc * rfid: generic fsk demodulator * rfid: protocol em4100 * rfid: protocol h10301 * rfid: protocol io prox xsf * Unit test: rfid protocols * rfid: new hal * rfid: raw worker * Unit test: fix error output * rfid: worker * rfid: plain c cli * fw: migrate to scons * lfrfid: full io prox support * unit test: io prox protocol * SubGHZ: move bit defines to source * FSK oscillator: level duration compability * libs: bit manipulation library * lfrfid: ioprox protocol, use bit library and new level duration method of FSK ocillator * bit lib: unit tests * Bit lib: parity tests, remove every nth bit, copy bits * Lfrfid: awid protocol * bit lib: uint16 and uint32 getters, unit tests * lfrfid: FDX-B read, draft version * Minunit: better memeq assert * bit lib: reverse, print, print regions * Protocol dict: get protocol features, get protocol validate count * lfrfid worker: improved read * lfrfid raw worker: psk support * Cli: rfid plain C cli * protocol AWID: render * protocol em4100: render * protocol h10301: render * protocol indala26: support every indala 26 scramble * Protocol IO Prox: render * Protocol FDX-B: advanced read * lfrfid: remove unused test function * lfrfid: fix os primitives * bit lib: crc16 and unit tests * FDX-B: save data * lfrfid worker: increase stream size. Alloc raw worker only when needed. * lfrfid: indala26 emulation * lfrfid: prepare to write * lfrfid: fdx-b emulation * lfrfid: awid, ioprox write * lfrfid: write t55xx w\o validation * lfrfid: better t55xx block0 handling * lfrfid: use new t5577 functions in worker * lfrfid: improve protocol description * lfrfid: write and verify * lfrfid: delete cpp cli * lfrfid: improve worker usage * lfrfid-app: step to new worker * lfrfid: old indala (I40134) load fallback * lfrfid: indala26, recover wrong synced data * lfrfid: remove old worker * lfrfid app: dummy read screen * lfrfid app: less dummy read screen * lfrfid: generic 96-bit HID protocol (covers up to HID 37-bit) * rename * lfrfid: improve indala26 read * lfrfid: generic 192-bit HID protocol (covers all HID extended) * lfrfid: TODO about HID render * lfrfid: new protocol FDX-A * lfrfid-app: correct worker stop on exit * misc fixes * lfrfid: FDX-A and HID distinguishability has been fixed. * lfrfid: decode HID size header and render it (#1612) * lfrfid: rename HID96 and HID192 to HIDProx and HIDExt * lfrfid: extra actions scene * lfrfid: decode generic HID Proximity size lazily (#1618) * lib: stream of data buffers concept * lfrfid: raw file helper * lfrfid: changed raw worker api * lfrfid: packed varint pair * lfrfid: read stream speedup * lfrfid app: show read mode * Documentation * lfrfid app: raw read gui * lfrfid app: storage check for raw read * memleak fix * review fixes * lfrfid app: read blink color * lfrfid app: reset key name after read * review fixes * lfrfid app: fix copypasted text * review fixes * lfrfid: disable debug gpio * lfrfid: card detection events * lfrfid: change validation color from magenta to green * Update core_defines. * lfrfid: prefix fdx-b id by zeroes * lfrfid: parse up to 43-bit HID Proximity keys (#1640) * Fbt: downgrade toolchain and fix PS1 * lfrfid: fix unit tests * lfrfid app: remove printf * lfrfid: indala26, use bit 55 as data * lfrfid: indala26, better brief format * lfrfid: indala26, loading fallback * lfrfid: read timing tuning Co-authored-by: James Ide <ide@users.noreply.github.com> Co-authored-by: あく <alleteam@gmail.com>
2022-08-23 15:57:39 +00:00
#include <furi.h>
#include <furi_hal.h>
#include "protocol_cyfral.h"
#define CYFRAL_DATA_SIZE sizeof(uint16_t)
#define CYFRAL_PERIOD (125 * furi_hal_cortex_instructions_per_microsecond())
#define CYFRAL_0_LOW (CYFRAL_PERIOD * 0.66f)
#define CYFRAL_0_HI (CYFRAL_PERIOD * 0.33f)
#define CYFRAL_1_LOW (CYFRAL_PERIOD * 0.33f)
#define CYFRAL_1_HI (CYFRAL_PERIOD * 0.66f)
#define CYFRAL_MAX_PERIOD_US 230
typedef enum {
CYFRAL_BIT_WAIT_FRONT_HIGH,
CYFRAL_BIT_WAIT_FRONT_LOW,
} CyfralBitState;
typedef enum {
CYFRAL_WAIT_START_NIBBLE,
CYFRAL_READ_NIBBLE,
CYFRAL_READ_STOP_NIBBLE,
} CyfralState;
typedef struct {
CyfralState state;
CyfralBitState bit_state;
// high + low period time
uint32_t period_time;
// temporary nibble storage
uint8_t nibble;
// data valid flag
// MUST be checked only in READ_STOP_NIBBLE state
bool data_valid;
// nibble index, we expect 8 nibbles
uint8_t index;
// bit index in nibble, 4 bit per nibble
uint8_t bit_index;
// max period, 230us x clock per us
uint32_t max_period;
} ProtocolCyfralDecoder;
typedef struct {
uint32_t data;
uint32_t index;
} ProtocolCyfralEncoder;
typedef struct {
uint16_t data;
ProtocolCyfralDecoder decoder;
ProtocolCyfralEncoder encoder;
} ProtocolCyfral;
static void* protocol_cyfral_alloc(void) {
ProtocolCyfral* proto = malloc(sizeof(ProtocolCyfral));
return (void*)proto;
}
static void protocol_cyfral_free(ProtocolCyfral* proto) {
free(proto);
}
static uint8_t* protocol_cyfral_get_data(ProtocolCyfral* proto) {
return (uint8_t*)&proto->data;
}
static void protocol_cyfral_decoder_start(ProtocolCyfral* proto) {
ProtocolCyfralDecoder* cyfral = &proto->decoder;
cyfral->state = CYFRAL_WAIT_START_NIBBLE;
cyfral->bit_state = CYFRAL_BIT_WAIT_FRONT_LOW;
cyfral->period_time = 0;
cyfral->bit_index = 0;
cyfral->index = 0;
cyfral->nibble = 0;
cyfral->data_valid = true;
cyfral->max_period = CYFRAL_MAX_PERIOD_US * furi_hal_cortex_instructions_per_microsecond();
proto->data = 0;
}
static bool protocol_cyfral_decoder_process_bit(
ProtocolCyfralDecoder* cyfral,
bool polarity,
uint32_t length,
bool* bit_ready,
bool* bit_value) {
bool result = true;
*bit_ready = false;
// bit start from low
switch(cyfral->bit_state) {
case CYFRAL_BIT_WAIT_FRONT_LOW:
if(polarity == true) {
cyfral->period_time += length;
*bit_ready = true;
if(cyfral->period_time <= cyfral->max_period) {
if((cyfral->period_time / 2) > length) {
*bit_value = false;
} else {
*bit_value = true;
}
} else {
result = false;
}
cyfral->bit_state = CYFRAL_BIT_WAIT_FRONT_HIGH;
} else {
result = false;
}
break;
case CYFRAL_BIT_WAIT_FRONT_HIGH:
if(polarity == false) {
cyfral->period_time = length;
cyfral->bit_state = CYFRAL_BIT_WAIT_FRONT_LOW;
} else {
result = false;
}
break;
}
return result;
}
static bool protocol_cyfral_decoder_feed(ProtocolCyfral* proto, bool level, uint32_t duration) {
ProtocolCyfralDecoder* cyfral = &proto->decoder;
bool bit_ready;
bool bit_value;
bool decoded = false;
switch(cyfral->state) {
case CYFRAL_WAIT_START_NIBBLE:
// wait for start word
if(protocol_cyfral_decoder_process_bit(cyfral, level, duration, &bit_ready, &bit_value)) {
if(bit_ready) {
cyfral->nibble = ((cyfral->nibble << 1) | bit_value) & 0x0F;
if(cyfral->nibble == 0b0001) {
cyfral->nibble = 0;
cyfral->state = CYFRAL_READ_NIBBLE;
}
}
} else {
protocol_cyfral_decoder_start(proto);
}
break;
case CYFRAL_READ_NIBBLE:
// read nibbles
if(protocol_cyfral_decoder_process_bit(cyfral, level, duration, &bit_ready, &bit_value)) {
if(bit_ready) {
cyfral->nibble = (cyfral->nibble << 1) | bit_value;
cyfral->bit_index++;
//convert every nibble to 2-bit index
if(cyfral->bit_index == 4) {
switch(cyfral->nibble) {
case 0b1110:
proto->data = (proto->data << 2) | 0b11;
break;
case 0b1101:
proto->data = (proto->data << 2) | 0b10;
break;
case 0b1011:
proto->data = (proto->data << 2) | 0b01;
break;
case 0b0111:
proto->data = (proto->data << 2) | 0b00;
break;
default:
cyfral->data_valid = false;
break;
}
cyfral->nibble = 0;
cyfral->bit_index = 0;
cyfral->index++;
}
// succefully read 8 nibbles
if(cyfral->index == 8) {
cyfral->state = CYFRAL_READ_STOP_NIBBLE;
}
}
} else {
protocol_cyfral_decoder_start(proto);
}
break;
case CYFRAL_READ_STOP_NIBBLE:
// read stop nibble
if(protocol_cyfral_decoder_process_bit(cyfral, level, duration, &bit_ready, &bit_value)) {
if(bit_ready) {
cyfral->nibble = ((cyfral->nibble << 1) | bit_value) & 0x0F;
cyfral->bit_index++;
switch(cyfral->bit_index) {
case 0:
case 1:
case 2:
case 3:
break;
case 4:
if(cyfral->nibble == 0b0001) {
// validate data
if(cyfral->data_valid) {
decoded = true;
} else {
protocol_cyfral_decoder_start(proto);
}
} else {
protocol_cyfral_decoder_start(proto);
}
break;
default:
protocol_cyfral_decoder_start(proto);
break;
}
}
} else {
protocol_cyfral_decoder_start(proto);
}
break;
}
return decoded;
}
static uint32_t protocol_cyfral_encoder_encode(const uint16_t data) {
uint32_t value = 0;
for(int8_t i = 0; i <= 7; i++) {
switch((data >> (i * 2)) & 0b00000011) {
case 0b11:
value = value << 4;
value += 0b00000111;
break;
case 0b10:
value = value << 4;
value += 0b00001011;
break;
case 0b01:
value = value << 4;
value += 0b00001101;
break;
case 0b00:
value = value << 4;
value += 0b00001110;
break;
default:
break;
}
}
return value;
}
static bool protocol_cyfral_encoder_start(ProtocolCyfral* proto) {
proto->encoder.index = 0;
proto->encoder.data = protocol_cyfral_encoder_encode(proto->data);
return true;
}
static LevelDuration protocol_cyfral_encoder_yield(ProtocolCyfral* proto) {
LevelDuration result;
if(proto->encoder.index < 8) {
// start word (0b0001)
switch(proto->encoder.index) {
case 0:
result = level_duration_make(false, CYFRAL_0_LOW);
break;
case 1:
result = level_duration_make(true, CYFRAL_0_HI);
break;
case 2:
result = level_duration_make(false, CYFRAL_0_LOW);
break;
case 3:
result = level_duration_make(true, CYFRAL_0_HI);
break;
case 4:
result = level_duration_make(false, CYFRAL_0_LOW);
break;
case 5:
result = level_duration_make(true, CYFRAL_0_HI);
break;
case 6:
result = level_duration_make(false, CYFRAL_1_LOW);
break;
case 7:
result = level_duration_make(true, CYFRAL_1_HI);
break;
}
} else {
// data
uint8_t data_start_index = proto->encoder.index - 8;
bool clock_polarity = (data_start_index) % 2;
uint8_t bit_index = (data_start_index) / 2;
bool bit_value = ((proto->encoder.data >> bit_index) & 1);
if(!clock_polarity) {
if(bit_value) {
result = level_duration_make(false, CYFRAL_1_LOW);
} else {
result = level_duration_make(false, CYFRAL_0_LOW);
}
} else {
if(bit_value) {
result = level_duration_make(true, CYFRAL_1_HI);
} else {
result = level_duration_make(true, CYFRAL_0_HI);
}
}
}
proto->encoder.index++;
if(proto->encoder.index >= (9 * 4 * 2)) {
proto->encoder.index = 0;
}
return result;
}
const ProtocolBase protocol_cyfral = {
.name = "Cyfral",
.manufacturer = "Cyfral",
.data_size = CYFRAL_DATA_SIZE,
.alloc = (ProtocolAlloc)protocol_cyfral_alloc,
.free = (ProtocolFree)protocol_cyfral_free,
.get_data = (ProtocolGetData)protocol_cyfral_get_data,
.decoder =
{
.start = (ProtocolDecoderStart)protocol_cyfral_decoder_start,
.feed = (ProtocolDecoderFeed)protocol_cyfral_decoder_feed,
},
.encoder =
{
.start = (ProtocolEncoderStart)protocol_cyfral_encoder_start,
.yield = (ProtocolEncoderYield)protocol_cyfral_encoder_yield,
},
};