Skip to content

Commit a3b8f9d

Browse files
acegoal07acegoal07
authored
Merge pull request #1 from acegoal07/dev
Dev
2 parents 8405236 + 8cba3d8 commit a3b8f9d

9 files changed

+267
-21
lines changed

‎README.md

+3-1
Original file line numberDiff line numberDiff line change
@@ -1 +1,3 @@
1-
# FlipperZero_NFC_Comparator
1+
# FlipperZero_NFC_Comparator
2+
3+
This is a simple tool to compare a stored NFC card against a physical card using a Flipper Zero device as of the moment it just checks the UID and protocol but i would like to add support for checking more variables to confirm how similar the NFC cards are.

‎application.fam

+2-2
Original file line numberDiff line numberDiff line change
@@ -5,9 +5,9 @@ App(
55
entry_point="nfc_comparator_main",
66
stack_size=4 * 1024,
77
fap_category="NFC",
8-
fap_version="0.1",
8+
fap_version="1.0",
99
fap_icon="assets/Comparator_10px.png",
10-
fap_description="A app to check if a physical NFC card is the same as a saved one",
10+
fap_description="A tool to check if a physical NFC card is the same as a saved one",
1111
fap_author="acegoal07",
1212
fap_weburl="https://github.com/acegoal07/FlipperZero_NFC_Comparator",
1313
fap_icon_assets="assets",

‎lib/reader_worker/nfc_comparator_reader_worker.c

+145-4
Original file line numberDiff line numberDiff line change
@@ -3,18 +3,159 @@
33
NfcComparatorReaderWorker* nfc_comparator_reader_worker_alloc() {
44
NfcComparatorReaderWorker* nfc_comparator_reader_worker =
55
malloc(sizeof(NfcComparatorReaderWorker));
6-
furi_assert(nfc_comparator_reader_worker);
76
nfc_comparator_reader_worker->nfc = nfc_alloc();
8-
nfc_comparator_reader_worker->nfc_device = nfc_device_alloc();
97
nfc_comparator_reader_worker->nfc_scanner =
108
nfc_scanner_alloc(nfc_comparator_reader_worker->nfc);
9+
nfc_comparator_reader_worker->thread = furi_thread_alloc_ex(
10+
"NfcComparatorReaderWorker",
11+
4096,
12+
nfc_comparator_reader_worker_task,
13+
nfc_comparator_reader_worker);
14+
nfc_comparator_reader_worker->state = NfcComparatorReaderWorkerState_Stopped;
1115
return nfc_comparator_reader_worker;
1216
}
1317

14-
void nfc_comparator_reader_worker_free(NfcComparatorReaderWorker* nfc_comparator_reader_worker) {
18+
void nfc_comparator_reader_worker_free(void* context) {
19+
NfcComparatorReaderWorker* nfc_comparator_reader_worker = context;
1520
furi_assert(nfc_comparator_reader_worker);
1621
nfc_free(nfc_comparator_reader_worker->nfc);
17-
nfc_device_free(nfc_comparator_reader_worker->nfc_device);
1822
nfc_scanner_free(nfc_comparator_reader_worker->nfc_scanner);
23+
furi_thread_free(nfc_comparator_reader_worker->thread);
1924
free(nfc_comparator_reader_worker);
2025
}
26+
27+
void nfc_comparator_reader_worker_scanner_callback(NfcScannerEvent event, void* context) {
28+
NfcComparatorReaderWorker* nfc_comparator_reader_worker = context;
29+
furi_assert(nfc_comparator_reader_worker);
30+
switch(event.type) {
31+
case NfcScannerEventTypeDetected:
32+
nfc_comparator_reader_worker->protocol = event.data.protocols;
33+
nfc_comparator_reader_worker->state = NfcComparatorReaderWorkerState_Polling;
34+
break;
35+
default:
36+
break;
37+
}
38+
}
39+
40+
NfcCommand nfc_comparator_reader_worker_poller_callback(NfcGenericEvent event, void* context) {
41+
NfcComparatorReaderWorker* nfc_comparator_reader_worker = context;
42+
furi_assert(nfc_comparator_reader_worker);
43+
UNUSED(event);
44+
NfcCommand command = NfcCommandStop;
45+
nfc_comparator_reader_worker->state = NfcComparatorReaderWorkerState_Comparing;
46+
return command;
47+
}
48+
49+
int32_t nfc_comparator_reader_worker_task(void* context) {
50+
NfcComparatorReaderWorker* nfc_comparator_reader_worker = context;
51+
nfc_comparator_reader_worker->nfc_scanner =
52+
nfc_scanner_alloc(nfc_comparator_reader_worker->nfc);
53+
54+
nfc_scanner_start(
55+
nfc_comparator_reader_worker->nfc_scanner,
56+
nfc_comparator_reader_worker_scanner_callback,
57+
nfc_comparator_reader_worker);
58+
59+
nfc_comparator_reader_worker->state = NfcComparatorReaderWorkerState_Scanning;
60+
while(nfc_comparator_reader_worker->state == NfcComparatorReaderWorkerState_Scanning) {
61+
furi_delay_ms(100);
62+
}
63+
nfc_scanner_stop(nfc_comparator_reader_worker->nfc_scanner);
64+
65+
NfcPoller* nfc_poller = nfc_poller_alloc(
66+
nfc_comparator_reader_worker->nfc, nfc_comparator_reader_worker->protocol[0]);
67+
68+
nfc_comparator_reader_worker->state = NfcComparatorReaderWorkerState_Polling;
69+
nfc_poller_start(
70+
nfc_poller, nfc_comparator_reader_worker_poller_callback, nfc_comparator_reader_worker);
71+
72+
while(nfc_comparator_reader_worker->state == NfcComparatorReaderWorkerState_Polling) {
73+
furi_delay_ms(100);
74+
}
75+
76+
nfc_poller_stop(nfc_poller);
77+
78+
NfcDevice* data = nfc_device_alloc();
79+
nfc_device_set_data(
80+
data,
81+
nfc_comparator_reader_worker->protocol[0],
82+
(NfcDeviceData*)nfc_poller_get_data(nfc_poller));
83+
84+
nfc_comparator_reader_worker->compare_checks.protocol =
85+
nfc_device_get_protocol_name(nfc_device_get_protocol(data)) ==
86+
nfc_device_get_protocol_name(
87+
nfc_device_get_protocol(nfc_comparator_reader_worker->loaded_nfc_card)) ?
88+
true :
89+
false;
90+
91+
nfc_poller_free(nfc_poller);
92+
93+
size_t poller_uid_len = 0;
94+
const uint8_t* poller_uid = nfc_device_get_uid(data, &poller_uid_len);
95+
FuriString* poller_uid_str = furi_string_alloc();
96+
for(size_t i = 0; i < poller_uid_len; i++) {
97+
furi_string_utf8_push(poller_uid_str, poller_uid[i]);
98+
}
99+
100+
nfc_device_free(data);
101+
102+
size_t loaded_uid_len = 0;
103+
const uint8_t* loaded_uid =
104+
nfc_device_get_uid(nfc_comparator_reader_worker->loaded_nfc_card, &loaded_uid_len);
105+
FuriString* loaded_uid_str = furi_string_alloc();
106+
for(size_t i = 0; i < loaded_uid_len; i++) {
107+
furi_string_utf8_push(loaded_uid_str, loaded_uid[i]);
108+
}
109+
110+
nfc_comparator_reader_worker->compare_checks.uid =
111+
furi_string_cmpi(loaded_uid_str, poller_uid_str) == 0 ? true : false;
112+
113+
furi_string_free(poller_uid_str);
114+
furi_string_free(loaded_uid_str);
115+
116+
nfc_comparator_reader_worker->state = NfcComparatorReaderWorkerState_Stopped;
117+
118+
return 0;
119+
}
120+
121+
void nfc_comparator_reader_worker_set_compare_nfc_device(void* context, NfcDevice* nfc_device) {
122+
NfcComparatorReaderWorker* nfc_comparator_reader_worker = context;
123+
furi_assert(nfc_comparator_reader_worker);
124+
nfc_comparator_reader_worker->loaded_nfc_card = nfc_device;
125+
}
126+
127+
bool nfc_comparator_reader_worker_is_running(void* context) {
128+
NfcComparatorReaderWorker* nfc_comparator_reader_worker = context;
129+
return nfc_comparator_reader_worker->state != NfcComparatorReaderWorkerState_Stopped;
130+
}
131+
132+
NfcComparatorReaderWorkerState nfc_comparator_reader_worker_get_state(void* context) {
133+
NfcComparatorReaderWorker* nfc_comparator_reader_worker = context;
134+
furi_assert(nfc_comparator_reader_worker);
135+
return nfc_comparator_reader_worker->state;
136+
}
137+
138+
void nfc_comparator_reader_worker_stop(void* context) {
139+
NfcComparatorReaderWorker* nfc_comparator_reader_worker = context;
140+
furi_assert(nfc_comparator_reader_worker);
141+
if(nfc_comparator_reader_worker->state != NfcComparatorReaderWorkerState_Stopped) {
142+
nfc_comparator_reader_worker->state = NfcComparatorReaderWorkerState_Stopped;
143+
}
144+
furi_thread_join(nfc_comparator_reader_worker->thread);
145+
}
146+
147+
void nfc_comparator_reader_worker_start(void* context) {
148+
NfcComparatorReaderWorker* nfc_comparator_reader_worker = context;
149+
furi_assert(nfc_comparator_reader_worker);
150+
if(nfc_comparator_reader_worker->state == NfcComparatorReaderWorkerState_Stopped) {
151+
nfc_comparator_reader_worker->state = NfcComparatorReaderWorkerState_Scanning;
152+
furi_thread_start(nfc_comparator_reader_worker->thread);
153+
}
154+
}
155+
156+
NfcComparatorReaderWorkerCompareChecks
157+
nfc_comparator_reader_worker_get_compare_checks(void* context) {
158+
NfcComparatorReaderWorker* nfc_comparator_reader_worker = context;
159+
furi_assert(nfc_comparator_reader_worker);
160+
return nfc_comparator_reader_worker->compare_checks;
161+
}

‎lib/reader_worker/nfc_comparator_reader_worker.h

+22-3
Original file line numberDiff line numberDiff line change
@@ -9,18 +9,37 @@
99
typedef enum {
1010
NfcComparatorReaderWorkerState_Scanning,
1111
NfcComparatorReaderWorkerState_Polling,
12+
NfcComparatorReaderWorkerState_Comparing,
1213
NfcComparatorReaderWorkerState_Stopped
1314
} NfcComparatorReaderWorkerState;
1415

16+
typedef struct {
17+
bool uid;
18+
bool protocol;
19+
} NfcComparatorReaderWorkerCompareChecks;
20+
1521
typedef struct {
1622
Nfc* nfc;
1723
FuriThread* thread;
18-
NfcProtocol protocol;
24+
NfcProtocol* protocol;
1925
NfcComparatorReaderWorkerState state;
20-
NfcDevice* nfc_device;
26+
NfcDevice* loaded_nfc_card;
2127
NfcPoller* nfc_poller;
2228
NfcScanner* nfc_scanner;
29+
NfcComparatorReaderWorkerCompareChecks compare_checks;
2330
} NfcComparatorReaderWorker;
2431

2532
NfcComparatorReaderWorker* nfc_comparator_reader_worker_alloc();
26-
void nfc_comparator_reader_worker_free(NfcComparatorReaderWorker* nfc_comparator_reader_worker);
33+
void nfc_comparator_reader_worker_free(void* context);
34+
35+
void nfc_comparator_reader_worker_scanner_callback(NfcScannerEvent event, void* context);
36+
NfcCommand nfc_comparator_reader_worker_poller_callback(NfcGenericEvent event, void* context);
37+
int32_t nfc_comparator_reader_worker_task(void* context);
38+
void nfc_comparator_reader_worker_set_compare_nfc_device(void* context, NfcDevice* nfc_device);
39+
40+
bool nfc_comparator_reader_worker_is_running(void* context);
41+
NfcComparatorReaderWorkerState nfc_comparator_reader_worker_get_state(void* context);
42+
void nfc_comparator_reader_worker_stop(void* context);
43+
void nfc_comparator_reader_worker_start(void* context);
44+
NfcComparatorReaderWorkerCompareChecks
45+
nfc_comparator_reader_worker_get_compare_checks(void* context);

‎nfc_comparator.c

+11-1
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,8 @@ static NfcComparator* nfc_comparator_alloc() {
2424
nfc_comparator->file_browser_output = furi_string_alloc();
2525
nfc_comparator->file_browser = file_browser_alloc(nfc_comparator->file_browser_output);
2626

27+
nfc_comparator->popup = popup_alloc();
28+
2729
view_dispatcher_set_event_callback_context(nfc_comparator->view_dispatcher, nfc_comparator);
2830
view_dispatcher_set_custom_event_callback(
2931
nfc_comparator->view_dispatcher, nfc_comparator_custom_callback);
@@ -38,6 +40,10 @@ static NfcComparator* nfc_comparator_alloc() {
3840
nfc_comparator->view_dispatcher,
3941
NfcComparatorView_FileBrowser,
4042
file_browser_get_view(nfc_comparator->file_browser));
43+
view_dispatcher_add_view(
44+
nfc_comparator->view_dispatcher,
45+
NfcComparatorView_Popup,
46+
popup_get_view(nfc_comparator->popup));
4147

4248
return nfc_comparator;
4349
}
@@ -47,14 +53,18 @@ static void nfc_comparator_free(NfcComparator* nfc_comparator) {
4753

4854
view_dispatcher_remove_view(nfc_comparator->view_dispatcher, NfcComparatorView_Submenu);
4955
view_dispatcher_remove_view(nfc_comparator->view_dispatcher, NfcComparatorView_FileBrowser);
56+
view_dispatcher_remove_view(nfc_comparator->view_dispatcher, NfcComparatorView_Popup);
5057

5158
scene_manager_free(nfc_comparator->scene_manager);
5259
view_dispatcher_free(nfc_comparator->view_dispatcher);
5360

5461
submenu_free(nfc_comparator->submenu);
5562
file_browser_free(nfc_comparator->file_browser);
5663
furi_string_free(nfc_comparator->file_browser_output);
57-
nfc_device_free(nfc_comparator->loaded_nfc_card);
64+
if(nfc_comparator->loaded_nfc_card) {
65+
nfc_device_free(nfc_comparator->loaded_nfc_card);
66+
}
67+
popup_free(nfc_comparator->popup);
5868

5969
free(nfc_comparator);
6070
}

‎nfc_comparator.h

+4-1
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,7 @@
1111
#include <gui/scene_manager.h>
1212
#include <gui/modules/submenu.h>
1313
#include <gui/modules/file_browser.h>
14+
#include <gui/modules/popup.h>
1415

1516
#include <nfc_device.h>
1617
#include <nfc_listener.h>
@@ -28,7 +29,8 @@
2829

2930
typedef enum {
3031
NfcComparatorView_Submenu,
31-
NfcComparatorView_FileBrowser
32+
NfcComparatorView_FileBrowser,
33+
NfcComparatorView_Popup
3234
} NfcComparatorViews;
3335

3436
typedef struct {
@@ -37,6 +39,7 @@ typedef struct {
3739
Submenu* submenu;
3840
FileBrowser* file_browser;
3941
FuriString* file_browser_output;
42+
Popup* popup;
4043
NfcDevice* loaded_nfc_card;
4144
} NfcComparator;
4245

‎scenes/nfc_comparator_scene_comparator.c

+69
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,69 @@
1+
2+
#include "../nfc_comparator.h"
3+
4+
void nfc_comparator_comparator_menu_callback(void* context, uint32_t index) {
5+
NfcComparator* nfc_comparator = context;
6+
scene_manager_handle_custom_event(nfc_comparator->scene_manager, index);
7+
}
8+
9+
void nfc_comparator_comparator_scene_on_enter(void* context) {
10+
NfcComparator* nfc_comparator = context;
11+
furi_assert(nfc_comparator);
12+
13+
popup_set_context(nfc_comparator->popup, nfc_comparator);
14+
view_dispatcher_switch_to_view(nfc_comparator->view_dispatcher, NfcComparatorView_Popup);
15+
16+
NfcComparatorReaderWorker* worker = nfc_comparator_reader_worker_alloc();
17+
nfc_comparator_reader_worker_set_compare_nfc_device(worker, nfc_comparator->loaded_nfc_card);
18+
nfc_comparator_reader_worker_start(worker);
19+
20+
while(nfc_comparator_reader_worker_is_running(worker)) {
21+
switch(nfc_comparator_reader_worker_get_state(worker)) {
22+
case NfcComparatorReaderWorkerState_Scanning:
23+
popup_set_header(nfc_comparator->popup, "Scanning....", 64, 5, AlignCenter, AlignTop);
24+
break;
25+
case NfcComparatorReaderWorkerState_Polling:
26+
popup_set_header(nfc_comparator->popup, "Polling....", 64, 5, AlignCenter, AlignTop);
27+
break;
28+
case NfcComparatorReaderWorkerState_Comparing:
29+
popup_set_header(nfc_comparator->popup, "Comparing....", 64, 5, AlignCenter, AlignTop);
30+
break;
31+
default:
32+
break;
33+
}
34+
furi_delay_ms(100);
35+
}
36+
nfc_comparator_reader_worker_stop(worker);
37+
38+
popup_set_header(nfc_comparator->popup, "Compare Results", 64, 5, AlignCenter, AlignTop);
39+
40+
NfcComparatorReaderWorkerCompareChecks checks =
41+
nfc_comparator_reader_worker_get_compare_checks(worker);
42+
nfc_comparator_reader_worker_free(worker);
43+
44+
FuriString* comparator = furi_string_alloc();
45+
furi_string_printf(
46+
comparator,
47+
"UID: %s\nProtocol: %s",
48+
checks.uid ? "Match" : "Mismatch",
49+
checks.protocol ? "Match" : "Mismatch");
50+
51+
char result_buffer[158];
52+
strncpy(result_buffer, furi_string_get_cstr(comparator), sizeof(result_buffer) - 1);
53+
54+
furi_string_free(comparator);
55+
56+
popup_set_text(nfc_comparator->popup, result_buffer, 64, 30, AlignCenter, AlignCenter);
57+
}
58+
59+
bool nfc_comparator_comparator_scene_on_event(void* context, SceneManagerEvent event) {
60+
UNUSED(context);
61+
UNUSED(event);
62+
bool consumed = false;
63+
return consumed;
64+
}
65+
66+
void nfc_comparator_comparator_scene_on_exit(void* context) {
67+
NfcComparator* nfc_comparator = context;
68+
popup_reset(nfc_comparator->popup);
69+
}

‎scenes/nfc_comparator_scene_config.h

+1
Original file line numberDiff line numberDiff line change
@@ -1,2 +1,3 @@
11
ADD_SCENE(nfc_comparator, main_menu, MainMenu)
22
ADD_SCENE(nfc_comparator, select_nfc_card, SelectNfcCard)
3+
ADD_SCENE(nfc_comparator, comparator, Comparator)

0 commit comments

Comments
 (0)