notBrad/flipper-zero-tutorials
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

LFRFID FSK GEO DEMO

Browse Source
This commit is contained in:
Derek Jamison 2024-05-17 22:49:40 -05:00
parent e6acfb405f
commit 307ac450ed
3 changed files with 369 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

311
rfid/fsk-geo/protocol_demo_fsk_geo.c Normal file
View File

@ -0,0 +1,311 @@
/**
* @file protocol_demo_fsk_geo.c
*
* This is an example of implementing a low-frequency (125kHz) RFID protocol
* using FSK modulation. This protocol is used to transmit geographical
* coordinates. The data is encoded in the following way:
* - 16 bits preamble (0xF337)
* - 64 bits of data (32 bits latitude, 32 bits longitude)
* - 8 bits of XOR parity
*
* You can create similar protocols, just be sure to change the preamble so
* that the decoder can distinguish between different protocols.
*
* Some FSK protocols decide to also Manchester encode the data, but this
* example does not do that. Manchester encoding would provide an additional
* layer of error detection (since data must be encoded as either 01 or 10).
*
*/
#include <furi.h>
#include <toolbox/protocols/protocol.h>
#include <lfrfid/tools/fsk_demod.h>
#include <lfrfid/tools/fsk_osc.h>
#include <bit_lib/bit_lib.h>
#include "lfrfid_protocols.h"
// 16us of jitter.
#define JITTER_TIME (20)
// 8 bytes of data.
#define DEMO_DECODED_DATA_SIZE (8)
// 2 byte header, 8 bytes data, 1 byte xor parity
#define DEMO_ENCODED_DATA_SIZE (11)
// 2 byte header, 8 bytes data, 1 byte xor parity
#define DEMO_ENCODED_DATA_BITS (2 * 8 + 8 * 8 + 8)
#define TAG "Demo FSK Geo"
typedef struct {
FSKDemod* fsk_demod;
} ProtocolDemoDecoder;
typedef struct {
FSKOsc* fsk_osc;
uint8_t encoded_index;
uint32_t pulse;
} ProtocolDemoEncoder;
typedef struct {
ProtocolDemoDecoder decoder;
ProtocolDemoEncoder encoder;
uint8_t encoded_data[DEMO_ENCODED_DATA_SIZE];
uint8_t data[DEMO_DECODED_DATA_SIZE];
} ProtocolDemo;
static ProtocolDemo* protocol_demo_alloc(void) {
ProtocolDemo* protocol = malloc(sizeof(ProtocolDemo));
protocol->decoder.fsk_demod = fsk_demod_alloc(64 - JITTER_TIME, 6, 80 + JITTER_TIME, 5);
protocol->encoder.fsk_osc = fsk_osc_alloc(8, 10, 50);
float* f = (float*)protocol->data;
*f = 36.63813; // Sample latitude
f = (float*)(protocol->data + 4);
*f = -93.28007; // Sample longitude
return protocol;
};
static void protocol_demo_free(ProtocolDemo* protocol) {
fsk_demod_free(protocol->decoder.fsk_demod);
fsk_osc_free(protocol->encoder.fsk_osc);
free(protocol);
};
static uint8_t* protocol_demo_get_data(ProtocolDemo* protocol) {
return protocol->data;
};
static void protocol_demo_decoder_start(ProtocolDemo* protocol) {
memset(protocol->encoded_data, 0, sizeof(uint8_t) * DEMO_ENCODED_DATA_SIZE);
};
static void protocol_demo_decoder_store_data(ProtocolDemo* protocol, bool data) {
bit_lib_push_bit(protocol->encoded_data, DEMO_ENCODED_DATA_SIZE, data);
}
static bool protocol_demo_can_be_decoded(const uint8_t* encoded_data) {
// Our preamble is 0xF337.
if(bit_lib_get_bits(encoded_data, 0, 8) != 0xF3) {
return false;
}
if(bit_lib_get_bits(encoded_data, 8, 8) != 0x37) {
return false;
}
// Checksum is XOR of each byte of data
uint8_t xor = 0;
for(int i = 0; i < DEMO_DECODED_DATA_SIZE; i++) {
xor ^= bit_lib_get_bits(encoded_data, 16 + i * 8, 8);
}
// Checksum is stored after data
if(xor != bit_lib_get_bits(encoded_data, 16 + DEMO_DECODED_DATA_SIZE * 8, 8)) {
return false;
}
return true;
}
static void protocol_demo_decode(const uint8_t* encoded_data, uint8_t* decoded_data) {
// Skip preamble, copy data.
// If data was Manchester encoded, decoded first (or copy every other bit).
bit_lib_copy_bits(decoded_data, 0, 8 * DEMO_DECODED_DATA_SIZE, encoded_data, 16);
}
static bool protocol_demo_decoder_feed(ProtocolDemo* protocol, bool level, uint32_t duration) {
bool value;
uint32_t count;
bool result = false;
fsk_demod_feed(protocol->decoder.fsk_demod, level, duration, &value, &count);
if(count > 0) {
// Store data and check if it can be decoded
for(size_t i = 0; i < count; i++) {
protocol_demo_decoder_store_data(protocol, value);
if(protocol_demo_can_be_decoded(protocol->encoded_data)) {
protocol_demo_decode(protocol->encoded_data, protocol->data);
result = true;
break;
}
}
}
return result;
};
static void protocol_demo_write_raw_bit(bool bit, uint8_t position, uint8_t* card_data) {
bit_lib_set_bits(card_data, position, bit, 1);
}
static void protocol_demo_encode(const uint8_t* decoded_data, uint8_t* encoded_data) {
uint8_t card_data[DEMO_ENCODED_DATA_SIZE] = {0};
// 0xF337 (1111001100110111) preamble
protocol_demo_write_raw_bit(1, 0, card_data);
protocol_demo_write_raw_bit(1, 1, card_data);
protocol_demo_write_raw_bit(1, 2, card_data);
protocol_demo_write_raw_bit(1, 3, card_data);
protocol_demo_write_raw_bit(0, 4, card_data);
protocol_demo_write_raw_bit(0, 5, card_data);
protocol_demo_write_raw_bit(1, 6, card_data);
protocol_demo_write_raw_bit(1, 7, card_data);
protocol_demo_write_raw_bit(0, 8, card_data);
protocol_demo_write_raw_bit(0, 9, card_data);
protocol_demo_write_raw_bit(1, 10, card_data);
protocol_demo_write_raw_bit(1, 11, card_data);
protocol_demo_write_raw_bit(0, 12, card_data);
protocol_demo_write_raw_bit(1, 13, card_data);
protocol_demo_write_raw_bit(1, 14, card_data);
protocol_demo_write_raw_bit(1, 15, card_data);
// Some protocols may want to Manchester encode the data, but this one does not.
bit_lib_copy_bits(card_data, 16, DEMO_DECODED_DATA_SIZE * 8, decoded_data, 0);
// Checksum is XOR of each byte of data
uint8_t xor = 0;
for(uint8_t i = 0; i < DEMO_DECODED_DATA_SIZE; i++) {
xor ^= decoded_data[i];
}
// Checksum is stored after data
bit_lib_copy_bits(card_data, 16 + DEMO_DECODED_DATA_SIZE * 8, 8, &xor, 0);
memcpy(encoded_data, &card_data, DEMO_ENCODED_DATA_SIZE);
}
static bool protocol_demo_encoder_start(ProtocolDemo* protocol) {
protocol_demo_encode(protocol->data, (uint8_t*)protocol->encoded_data);
protocol->encoder.encoded_index = 0;
protocol->encoder.pulse = 0;
return true;
};
static LevelDuration protocol_demo_encoder_yield(ProtocolDemo* protocol) {
bool level = 0;
uint32_t duration = 0;
// if pulse is zero, we need to output high, otherwise we need to output low
if(protocol->encoder.pulse == 0) {
// get bit
uint8_t bit = bit_lib_get_bits(
(uint8_t*)protocol->encoded_data, protocol->encoder.encoded_index, 1) &
1;
// get pulse from oscillator
bool advance = fsk_osc_next(protocol->encoder.fsk_osc, bit, &duration);
if(advance) {
protocol->encoder.encoded_index++;
if(protocol->encoder.encoded_index >= (DEMO_ENCODED_DATA_BITS)) {
protocol->encoder.encoded_index = 0;
}
}
// duration divided by 2 because we need to output high and low
duration = duration / 2;
protocol->encoder.pulse = duration;
level = true;
} else {
// output low half and reset pulse
duration = protocol->encoder.pulse;
protocol->encoder.pulse = 0;
level = false;
}
return level_duration_make(level, duration);
};
static bool protocol_demo_write_data(ProtocolDemo* protocol, void* data) {
LFRFIDWriteRequest* request = (LFRFIDWriteRequest*)data;
bool result = false;
protocol_demo_encoder_start(protocol);
if(request->write_type == LFRFIDWriteTypeT5577) {
request->t5577.block[0] = LFRFID_T5577_MODULATION_FSK2a | LFRFID_T5577_BITRATE_RF_50 |
(3 << LFRFID_T5577_MAXBLOCK_SHIFT);
request->t5577.block[1] = bit_lib_get_bits_32(protocol->encoded_data, 0, 32);
request->t5577.block[2] = bit_lib_get_bits_32(protocol->encoded_data, 32, 32);
// Since we only have 3 bytes of data, we need to shift the last byte by 8 bits
// so we send "123456" as "12345600" instead of "00123456" (with 0s in the middle
// of our signal).
request->t5577.block[3] = bit_lib_get_bits_32(protocol->encoded_data, 64, 24) << 8;
request->t5577.blocks_to_write = 4;
result = true;
FURI_LOG_D(
TAG,
"T5577 Write data: %08lX %08lX %08lX",
request->t5577.block[1],
request->t5577.block[2],
request->t5577.block[3]);
}
return result;
};
static void protocol_demo_render_data(ProtocolDemo* protocol, FuriString* result) {
uint8_t* data = protocol->data;
float* lat = (float*)data;
float* lon = (float*)(data + 4);
furi_string_printf(
result,
"Lat: %f\n"
"Long: %f",
(double)*lat,
(double)*lon);
};
static void protocol_demo_render_brief_data(ProtocolDemo* protocol, FuriString* result) {
uint8_t* data = protocol->data;
float* lat = (float*)data;
float* lon = (float*)(data + 4);
furi_string_printf(result, "(%f,%f)", (double)*lat, (double)*lon);
};
/*
// https://onlinegdb.com/UHHaOKrpj
// E.g. 36.0352, -86.6797 => 0B 24 10 42 02 5C AD C2
#include <stdio.h>
#include <stdint.h>
int main() {
float f,lat,lon;
printf("enter latitude,longitude: "); // E.g. 36.0352, -86.6797
scanf("%f,%f", &lat,&lon);
f = lat;
uint8_t* lat_p = (uint8_t*)&f;
printf("%02X %02X %02X %02X ", *lat_p, *(lat_p+1),*(lat_p+2),*(lat_p+3));
f = lon;
printf("%02X %02X %02X %02X", *lat_p, *(lat_p+1),*(lat_p+2),*(lat_p+3));
return 0;
}
*/
const ProtocolBase protocol_demo_fsk_geo = {
.name = "FEE7",
.manufacturer = "JAMISON",
.data_size = DEMO_DECODED_DATA_SIZE,
.features = LFRFIDFeatureASK,
.validate_count = 3,
.alloc = (ProtocolAlloc)protocol_demo_alloc,
.free = (ProtocolFree)protocol_demo_free,
.get_data = (ProtocolGetData)protocol_demo_get_data,
.decoder =
{
.start = (ProtocolDecoderStart)protocol_demo_decoder_start,
.feed = (ProtocolDecoderFeed)protocol_demo_decoder_feed,
},
.encoder =
{
.start = (ProtocolEncoderStart)protocol_demo_encoder_start,
.yield = (ProtocolEncoderYield)protocol_demo_encoder_yield,
},
.render_data = (ProtocolRenderData)protocol_demo_render_data,
.render_brief_data = (ProtocolRenderData)protocol_demo_render_brief_data,
.write_data = (ProtocolWriteData)protocol_demo_write_data,
};

4
rfid/fsk-geo/protocol_demo_fsk_geo.h Normal file
View File

@ -0,0 +1,4 @@
#pragma once
#include <toolbox/protocols/protocol.h>
extern const ProtocolBase protocol_demo_fsk_geo;

54
rfid/fsk-geo/readme.md Normal file
View File

@ -0,0 +1,54 @@
# fsk-geo
## Description
This is a simple project that adds a new protocol to the Flipper Zero low-frequency RFID. This gives the Flipper Zero the ability to read and write low-frequency RFID tags that contain Geolocation information. The data is transmitted using FSK (Frequency Shift Keying) modulation. When a tag is read, the data is decoded and the latitude and longitude is displayed on the Flipper Zero screen.
[![Flipper Zero: Geolocation RFID tags](https://img.youtube.com/vi/5AjMLMdK3f4/0.jpg)](https://youtu.be/5AjMLMdK3f4)
## Installation
To install this project, you will need to have a Flipper Zero and clone the firmware that you are using.
On Official firmware:
- `git clone --recursive https://github.com/flipperdevices/flipperzero-firmware.git`
- `cd flipperzero-firmware`
For other firmware, see [my wiki](https://github.com/jamisonderek/flipper-zero-tutorials/wiki/Install-Firmware-and-Apps#step-3-recursively-clone-the-firmware-you-want-to-use).
Copy the two files (`protocol_demo_fsk_geo.c` and `protocol_demo_fsk_geo.h`) from this project into the `lib/lfrfid/protocols` directory of the firmware that you are using.
Add the text `LFRFIDProtocolDemoFskGeo,` above the entry `LFRFIDProtocolEM4100,` in the `lib/lfrfid/protocols/lfrfid_protocols.h` file.
Add the text `#include "protocol_demo_fsk_geo.h"` above the entry `#include "protocol_em4100.h"` in the `lib/lfrfid/protocols/lfrfid_protocols.c` file.
Add the text `[LFRFIDProtocolDemoFskGeo] = &protocol_demo_fsk_geo,` above the entry `[LFRFIDProtocolEM4100] = &protocol_em4100,` in the `lib/lfrfid/protocols/lfrfid_protocols.c` file.
Compile the firmware and flash it to your Flipper Zero.
- Run the command `./fbt COMPACT=1 DEBUG=0 FORCE=1 flash_usb_full`
- or in VS Code, run `Terminal -> Run Task -> Flash (USB, w/Resources)`
## Geolocation data
In Google Maps, you can right-click on a location and copy the latitude and longitude of that location. You can then load [https://www.onlinegdb.com/UHHaOKrpj](https://www.onlinegdb.com/UHHaOKrpj). Click the `Run` button and paste the latitude and longitude into the text box. The program will output the 8-bytes of data that you can use to write to the RFID tag.
## Flipper Zero
Creating a LFRFID file...
On the Flipper Zero, select `125 kHz RFID`, `Add Manually`, then `JAMISON F337`.
Enter the 8 bytes of data that represent the latitude and longitude, then click `Save`.
Writing a tag to a T5577...
On the Flipper Zero, select `125 kHz RFID`, `Saved`, then select the file you created previously. Place a T5577 tag against the back of the Flipper and choose `Write`. You should see a `Success` message once the tag has been written.
Emulating a tag...
On the Flipper Zero, select `125 kHz RFID`, `Saved`, then select the file you created previously. Choose `Emulate`. You can now place the Flipper Zero against a reader and it will read the latitude and longitude data.
Reading a tag...
On the Flipper Zero, select `125 kHz RFID`, `Read`. Place the tag against the back of the Flipper (or use another Flipper that is emulating the tag) and you should see the latitude and longitude displayed on the screen.
## Support
The best way to get support is to join the Flipper Zero Tutorials (Unofficial) Discord community. Here is a [Discord invite](https://discord.com/invite/NsjCvqwPAd) to join my `Flipper Zero Tutorials (Unofficial)` community.
If you want to support my work, you can donate via [https://ko-fi.com/codeallnight](https://ko-fi.com/codeallnight) or you can [buy a FlipBoard](https://www.tindie.com/products/makeithackin/flipboard-macropad-keyboard-for-flipper-zero/) from HackItHackin with software & tutorials from me (@CodeAllNight).