still experimental changes, epc, user not working

scenes/uhf_scene_read_tag.c

@@ -29,7 +29,6 @@ void uhf_scene_read_tag_on_enter(void* ctx) {
 }
 
 bool uhf_scene_read_tag_on_event(void* ctx, SceneManagerEvent event) {
-    // UNUSED(ctx);
     UHFApp* uhf_app = ctx;
     bool consumed = false;
     if(event.event == UHFCustomEventWorkerExit) {

scenes/uhf_scene_read_tag_success.c

@@ -16,10 +16,9 @@ void uhf_scene_read_card_success_widget_callback(GuiButtonType result, InputType
 
 void uhf_scene_read_tag_success_on_enter(void* ctx) {
     UHFApp* uhf_app = ctx;
-
-    const uint8_t* read_data =
-        uhf_response_data_get_uhf_data(uhf_app->worker->response_data, 0)->data;
-
+    FURI_LOG_E("TAG", "working till here 6");
+    UHFTag* uhf_tag = uhf_app->worker->uhf_tag;
+    FURI_LOG_E("TAG", "working till here 7");
     widget_add_string_element(
         uhf_app->widget, 32, 5, AlignLeft, AlignCenter, FontPrimary, "Read Success");
 
@@ -31,32 +30,35 @@ void uhf_scene_read_tag_success_on_enter(void* ctx) {
     widget_add_string_element(
         uhf_app->widget, 3, 32, AlignLeft, AlignCenter, FontPrimary, "EPC :");
 
-    widget_add_string_element(
-        uhf_app->widget,
-        26,
-        19,
-        AlignLeft,
-        AlignCenter,
-        FontKeyboard,
-        convertToHexString(read_data + 6, 2));
-    widget_add_string_element(
-        uhf_app->widget,
-        96,
-        19,
-        AlignLeft,
-        AlignCenter,
-        FontKeyboard,
-        convertToHexString(read_data + 20, 2));
-
-    widget_add_string_multiline_element(
-        uhf_app->widget,
-        34,
-        29,
-        AlignLeft,
-        AlignTop,
-        FontKeyboard,
-        convertToHexString(read_data + 8, 12));
-
+    FURI_LOG_E("TAG", "crc %02x %02x", uhf_tag->crc[0], uhf_tag->crc[1]);
+
+    // widget_add_string_element(
+    //     uhf_app->widget,
+    //     26,
+    //     19,
+    //     AlignLeft,
+    //     AlignCenter,
+    //     FontKeyboard,
+    //     convertToHexString((uint8_t*)&uhf_tag->pc, 2));
+    // FURI_LOG_E("TAG", "working till here 8");
+    // widget_add_string_element(
+    //     uhf_app->widget,
+    //     96,
+    //     19,
+    //     AlignLeft,
+    //     AlignCenter,
+    //     FontKeyboard,
+    //     convertToHexString((uint8_t*)&uhf_tag->crc, 2));
+    // FURI_LOG_E("TAG", "working till here 9");
+    // widget_add_string_multiline_element(
+    //     uhf_app->widget,
+    //     34,
+    //     29,
+    //     AlignLeft,
+    //     AlignTop,
+    //     FontKeyboard,
+    //     convertToHexString((uint8_t*)&uhf_tag->epc, uhf_tag->epc_length));
+    // FURI_LOG_E("TAG", "working till here 10");
     widget_add_button_element(
         uhf_app->widget,
         GuiButtonTypeRight,

uhf_app.c

@@ -70,8 +70,11 @@ UHFApp* uhf_alloc() {
 
     // device
     uhf_app->uhf_device = uhf_device_alloc();
-    // use same linked list
-    uhf_app->uhf_device->dev_data = uhf_app->worker->response_data;
+
+    UHFTag* uhf_tag = uhf_tag_alloc();
+    // point tag object to worker
+    uhf_app->worker->uhf_tag = uhf_tag;
+    uhf_app->uhf_device->uhf_tag = uhf_tag;
 
     // Open Notification record
     uhf_app->notifications = furi_record_open(RECORD_NOTIFICATION);
@@ -131,6 +134,9 @@ void uhf_free(UHFApp* uhf_app) {
     uhf_worker_stop(uhf_app->worker);
     uhf_worker_free(uhf_app->worker);
 
+    // Tag
+    uhf_tag_free(uhf_app->worker->uhf_tag);
+
     // View Dispatcher
     view_dispatcher_free(uhf_app->view_dispatcher);
 

uhf_app_i.h

@@ -28,8 +28,8 @@
 
 #define UHF_TEXT_STORE_SIZE 128
 // #define UHF_APPS_DATA_FOLDER EXT_PATH("apps_data")
-// #define UHF_APPS_STORAGE_FOLDER 
-//     UHF_APPS_DATA_FOLDER "/"    
+// #define UHF_APPS_STORAGE_FOLDER
+//     UHF_APPS_DATA_FOLDER "/"
 //                          "uhf_rfid"
 // #define UHF_FILE_EXTENSION ".uhf"
 
@@ -59,7 +59,6 @@ struct UHFApp {
     UHFDevice* uhf_device;
     char text_store[UHF_TEXT_STORE_SIZE + 1];
     FuriString* text_box_store;
-
     // Common Views
     Submenu* submenu;
     Popup* popup;

uhf_data.c

@@ -1,4 +1,3 @@
-#include <furi.h>
 #include "uhf_data.h"
 
 UHFData* uhf_data_alloc() {
@@ -61,41 +60,6 @@ void uhf_data_free(UHFData* uhf_data) {
     }
 }
 
-UHFTag* uhf_tag_alloc() {
-    UHFTag* uhf_tag = (UHFTag*)malloc(sizeof(UHFTag));
-    return uhf_tag;
-}
-
-void uhf_tag_set_epc(UHFTag* uhf_tag, uint8_t* data) {
-    // ED 1A 34 00 22 11 22 11 22 11 22 11 22 11 22 11
-    // memcpy((void*)&select_cmd->data, (void*)&CMD_SET_SELECT_PARAMETER.cmd[0], select_cmd->length);
-    memcpy(&uhf_tag->CRC, &data, 2);
-    data += 2;
-    memcpy(&uhf_tag->PC, data, 2);
-    uint16_t epc_length = uhf_tag->PC[0];
-    epc_length <<= 1;
-    epc_length += uhf_tag->PC[1] & 0x08;
-    epc_length *= 2;
-    uhf_tag->epc_length = epc_length;
-    memcpy(&uhf_tag->EPC, &data, (size_t)epc_length);
-}
-
-void uhf_tag_set_tid(UHFTag* uhf_tag, uint8_t* data) {
-    memcpy(&uhf_tag->CRC, &data, 2);
-    data += 2;
-    memcpy(&uhf_tag->PC, data, 2);
-    uint16_t epc_length = uhf_tag->PC[0];
-    epc_length <<= 1;
-    epc_length += uhf_tag->PC[1] & 0x08;
-    epc_length *= 2;
-    uhf_tag->epc_length = epc_length;
-    memcpy(&uhf_tag->EPC, &data, (size_t)epc_length);
-}
-
-void uhf_tag_free(UHFTag* uhf_tag) {
-    free(uhf_tag);
-}
-
 UHFResponseData* uhf_response_data_alloc() {
     UHFResponseData* uhf_response_data = (UHFResponseData*)malloc(sizeof(UHFResponseData));
     uhf_response_data->head = uhf_data_alloc();
@@ -138,4 +102,31 @@ void uhf_response_data_reset(UHFResponseData* uhf_response_data) {
 void uhf_response_data_free(UHFResponseData* uhf_response_data) {
     uhf_data_free(uhf_response_data->head);
     free(uhf_response_data);
+}
+
+UHFTag* uhf_tag_alloc() {
+    UHFTag* uhf_tag = (UHFTag*)malloc(sizeof(UHFTag));
+    return uhf_tag;
+}
+
+void uhf_tag_set_epc(UHFTag* uhf_tag, uint8_t* data, size_t length) {
+    memcpy(&uhf_tag->crc, &data, 2);
+    data += 2;
+    memcpy(&uhf_tag->pc, data, 2);
+    data += 2;
+    memcpy(&uhf_tag->epc, &data, length);
+}
+
+void uhf_tag_set_tid(UHFTag* uhf_tag, uint8_t* data, size_t length) {
+    memcpy(&uhf_tag->tid, &data, length);
+    uhf_tag->tid_length = length;
+}
+
+void uhf_tag_set_user(UHFTag* uhf_tag, uint8_t* data, size_t length) {
+    memcpy(&uhf_tag->user, &data, length);
+    uhf_tag->user_length = length;
+}
+
+void uhf_tag_free(UHFTag* uhf_tag) {
+    free(uhf_tag);
 }

uhf_data.h

@@ -2,9 +2,12 @@
 
 #include <stdint.h>
 #include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
 
 #define MAX_DATA_SIZE 128
 #define MAX_BANK_SIZE 64
+typedef unsigned int uint;
 
 typedef struct UHFData {
     uint8_t data[MAX_DATA_SIZE];
@@ -19,25 +22,24 @@ typedef struct UHFResponseData {
     UHFData* head;
     UHFData* tail;
     size_t size;
-
 } UHFResponseData;
 
 typedef struct UHFTag {
     // RESERVED BANK (RFU) (00)
-    uint8_t KILL_PWD[2]; // 0x00-0x10
-    uint8_t ACCESS_PWD[2]; // 0x10-0x20
+    uint8_t kill_pwd[2]; // 0x00-0x10
+    uint8_t access_pwd[2]; // 0x10-0x20
     // EPC Bank
-    uint8_t CRC[2]; // 0x00-0x10
-    uint8_t PC[2]; // 0x10-0x20
-    uint8_t EPC[MAX_BANK_SIZE]; // 0x20-0x210
+    uint8_t crc[2]; // 0x00-0x10
+    uint8_t pc[2]; // 0x10-0x20
+    uint8_t epc[MAX_BANK_SIZE]; // 0x20-0x210
     size_t epc_length;
-    uint8_t XPC[2]; // 0x210-0x21F
+    uint8_t xpc[2]; // 0x210-0x21F
     size_t xpc_length;
     // TID Bank
-    uint8_t TID[MAX_BANK_SIZE]; // 0x00-END
+    uint8_t tid[MAX_BANK_SIZE]; // 0x00-END
     size_t tid_length;
     // USER Bank
-    uint8_t USER[MAX_BANK_SIZE]; // 0x00-END
+    uint8_t user[MAX_BANK_SIZE]; // 0x00-END
     size_t user_length;
 } UHFTag;
 
@@ -54,5 +56,8 @@ UHFData* uhf_response_data_get_uhf_data(UHFResponseData* uhf_response_data, uint
 void uhf_response_data_reset(UHFResponseData* uhf_response_data);
 void uhf_response_data_free(UHFResponseData* uhf_response_data);
 
-UHFBank* uhf_tag_alloc();
-void uhf_tag_free(UHFTag* uhf_tag);
+UHFTag* uhf_tag_alloc();
+void uhf_tag_set_epc(UHFTag* uhf_tag, uint8_t* data, size_t length);
+void uhf_tag_set_tid(UHFTag* uhf_tag, uint8_t* data, size_t length);
+void uhf_tag_set_user(UHFTag* uhf_tag, uint8_t* data, size_t length);
+void uhf_tag_free(UHFTag* uhf_tag);

uhf_device.c

@@ -8,8 +8,8 @@
 
 static const char* uhf_file_header = "Flipper UHF RFID device";
 static const uint32_t uhf_file_version = 1;
-static const uint8_t bank_data_start = 20;
-static const uint8_t bank_data_length = 16;
+// static const uint8_t bank_data_start = 20;
+// static const uint8_t bank_data_length = 16;
 
 UHFDevice* uhf_device_alloc() {
     UHFDevice* uhf_device = malloc(sizeof(UHFDevice));
@@ -33,12 +33,14 @@ static bool uhf_device_save_file(
     bool use_load_path) {
     furi_assert(dev);
 
-    UHFResponseData* uhf_response_data = dev->dev_data;
+    UHFTag* uhf_tag = dev->uhf_tag;
     bool saved = false;
     FlipperFormat* file = flipper_format_file_alloc(dev->storage);
     FuriString* temp_str;
     temp_str = furi_string_alloc();
-
+    FURI_LOG_E("TAG", "epc_len = %d", uhf_tag->epc_length);
+    FURI_LOG_E("TAG", "tid_len = %d", uhf_tag->tid_length);
+    FURI_LOG_E("TAG", "user_len = %d", uhf_tag->user_length);
     do {
         if(use_load_path && !furi_string_empty(dev->load_path)) {
             // Get directory name
@@ -54,52 +56,26 @@ static bool uhf_device_save_file(
 
         // Write header
         if(!flipper_format_write_header_cstr(file, uhf_file_header, uhf_file_version)) break;
-        // write rfu data to file
-        UHFData* rfu_data = uhf_response_data_get_uhf_data(uhf_response_data, 1);
-        if(rfu_data->length) {
-            if(!flipper_format_write_hex(
-                   file, UHF_RFU_BANK, rfu_data->data + bank_data_start, bank_data_length))
-                return false;
-        } else {
-            if(!flipper_format_write_hex(
-                   file, UHF_RFU_BANK, UHF_BANK_DOES_NOT_EXIST, bank_data_length))
-                return false;
-        }
-
-        // write epc data to file
-        UHFData* epc_data = uhf_response_data_get_uhf_data(uhf_response_data, 2);
-        if(epc_data->length) {
-            if(!flipper_format_write_hex(
-                   file, UHF_EPC_BANK, epc_data->data + bank_data_start, bank_data_length))
-                return false;
-        } else {
-            if(!flipper_format_write_hex(
-                   file, UHF_EPC_BANK, UHF_BANK_DOES_NOT_EXIST, bank_data_length))
-                return false;
-        }
 
-        // write tid data to file
-        UHFData* tid_data = uhf_response_data_get_uhf_data(uhf_response_data, 3);
-        if(tid_data->length) {
-            if(!flipper_format_write_hex(
-                   file, UHF_TID_BANK, tid_data->data + bank_data_start, bank_data_length))
-                return false;
-        } else {
-            if(!flipper_format_write_hex(
-                   file, UHF_TID_BANK, UHF_BANK_DOES_NOT_EXIST, bank_data_length))
-                return false;
-        }
-        // write user data to file
-        UHFData* user_data = uhf_response_data_get_uhf_data(uhf_response_data, 4);
-        if(user_data->length) {
-            if(!flipper_format_write_hex(
-                   file, UHF_USER_BANK, user_data->data + bank_data_start, bank_data_length))
-                return false;
-        } else {
-            if(!flipper_format_write_hex(
-                   file, UHF_USER_BANK, UHF_BANK_DOES_NOT_EXIST, bank_data_length))
-                return false;
-        }
+        // Reserved bank might be added
+        // todo : maybe
+        uint32_t temp_arr[1];
+        // write epc
+        temp_arr[0] = uhf_tag->epc_length;
+        if(!flipper_format_write_uint32(file, UHF_EPC_BANK_LENGTH_LABEL, temp_arr, 1)) break;
+        if(!flipper_format_write_hex(file, UHF_EPC_BANK_LABEL, uhf_tag->epc, uhf_tag->epc_length))
+            break;
+        // write tid
+        temp_arr[0] = uhf_tag->tid_length;
+        if(!flipper_format_write_uint32(file, UHF_TID_BANK_LENGTH_LABEL, temp_arr, 1)) break;
+        if(!flipper_format_write_hex(file, UHF_TID_BANK_LABEL, uhf_tag->tid, uhf_tag->tid_length))
+            break;
+        // write user
+        temp_arr[0] = uhf_tag->user_length;
+        if(!flipper_format_write_uint32(file, UHF_USER_BANK_LENGTH_LABEL, temp_arr, 1)) break;
+        if(!flipper_format_write_hex(
+               file, UHF_USER_BANK_LABEL, uhf_tag->user, uhf_tag->user_length))
+            break;
         saved = true;
     } while(0);
 
@@ -122,13 +98,12 @@ bool uhf_device_save(UHFDevice* dev, const char* dev_name) {
 static bool uhf_device_load_data(UHFDevice* dev, FuriString* path, bool show_dialog) {
     bool parsed = false;
     FlipperFormat* file = flipper_format_file_alloc(dev->storage);
-    UHFResponseData* uhf_response_data = dev->dev_data;
-    // reset response list
-    uhf_response_data_reset(uhf_response_data);
+    // UHFResponseData* uhf_response_data = dev->dev_data;
     FuriString* temp_str;
     temp_str = furi_string_alloc();
     bool deprecated_version = false;
-
+    UHFTag* uhf_tag = dev->uhf_tag;
+    uint32_t temp_arr[1];
     if(dev->loading_cb) {
         dev->loading_cb(dev->loading_cb_ctx, true);
     }
@@ -143,27 +118,24 @@ static bool uhf_device_load_data(UHFDevice* dev, FuriString* path, bool show_dia
             deprecated_version = true;
             break;
         }
+        // read epc
+        if(!flipper_format_read_uint32(file, UHF_EPC_BANK_LENGTH_LABEL, temp_arr, 1)) break;
+        uhf_tag->epc_length = temp_arr[0];
+        if(!flipper_format_read_hex(file, UHF_EPC_BANK_LABEL, uhf_tag->epc, uhf_tag->epc_length))
+            break;
 
-        // Parse RFU Bank
-        UHFData* rfu_bank = uhf_response_data_get_uhf_data(uhf_response_data, 0);
-        if(!flipper_format_read_hex(file, UHF_RFU_BANK, rfu_bank->data, bank_data_length)) break;
-
-        rfu_bank->length = bank_data_length;
-
-        // Parse EPC Bank
-        UHFData* epc_bank = uhf_response_data_add_new_uhf_data(uhf_response_data);
-        if(!flipper_format_read_hex(file, UHF_EPC_BANK, epc_bank->data, bank_data_length)) break;
-        epc_bank->length = bank_data_length;
+        // read tid
+        if(!flipper_format_read_uint32(file, UHF_TID_BANK_LENGTH_LABEL, temp_arr, 1)) break;
+        uhf_tag->tid_length = temp_arr[0];
+        if(!flipper_format_read_hex(file, UHF_TID_BANK_LABEL, uhf_tag->tid, uhf_tag->tid_length))
+            break;
 
-        // Parse TID Bank
-        UHFData* tid_bank = uhf_response_data_add_new_uhf_data(uhf_response_data);
-        if(!flipper_format_read_hex(file, UHF_TID_BANK, tid_bank->data, bank_data_length)) break;
-        tid_bank->length = bank_data_length;
+        // read user
+        if(!flipper_format_read_uint32(file, UHF_USER_BANK_LENGTH_LABEL, temp_arr, 1)) break;
+        uhf_tag->user_length = temp_arr[0];
+        if(!flipper_format_read_hex(file, UHF_USER_BANK_LABEL, uhf_tag->user, uhf_tag->user_length))
+            break;
 
-        // Parse USER Bank
-        UHFData* user_bank = uhf_response_data_add_new_uhf_data(uhf_response_data);
-        if(!flipper_format_read_hex(file, UHF_USER_BANK, user_bank->data, bank_data_length)) break;
-        user_bank->length = bank_data_length;
         parsed = true;
     } while(false);
 
@@ -196,11 +168,9 @@ static bool uhf_device_load_data(UHFDevice* dev, FuriString* path, bool show_dia
 
 void uhf_device_free(UHFDevice* uhf_dev) {
     furi_assert(uhf_dev);
-    // picopass_device_clear(uhf_dev);
     furi_record_close(RECORD_STORAGE);
     furi_record_close(RECORD_DIALOGS);
     furi_string_free(uhf_dev->load_path);
-    uhf_response_data_free(uhf_dev->dev_data);
     free(uhf_dev);
 }
 

uhf_device.h

@@ -10,78 +10,33 @@
 // #include "rfal_picopass.h"
 
 #define UHF_DEV_NAME_MAX_LEN 22
-#define PICOPASS_READER_DATA_MAX_SIZE 64
-#define PICOPASS_BLOCK_LEN 8
-#define PICOPASS_MAX_APP_LIMIT 32
+// #define PICOPASS_READER_DATA_MAX_SIZE 64
+// #define PICOPASS_BLOCK_LEN 8
+// #define PICOPASS_MAX_APP_LIMIT 32
 #define UHF_BANK_DOES_NOT_EXIST                                                                   \
     (uint8_t[]) {                                                                                 \
         0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, \
             0xFF                                                                                  \
     }
-#define UHF_RFU_BANK "RFU"
-#define UHF_EPC_BANK "EPC"
-#define UHF_TID_BANK "TID"
-#define UHF_USER_BANK "USER"
+
+#define UHF_EPC_BANK_LENGTH_LABEL "EPC_LENGTH"
+#define UHF_TID_BANK_LENGTH_LABEL "TID_LENGTH"
+#define UHF_USER_BANK_LENGTH_LABEL "USER_LENGTH"
+#define UHF_RFU_BANK_LABEL "RFU"
+#define UHF_EPC_BANK_LABEL "EPC"
+#define UHF_TID_BANK_LABEL "TID"
+#define UHF_USER_BANK_LABEL "USER"
 
 #define UHF_APP_EXTENSION ".uhf"
 // #define PICOPASS_APP_SHADOW_EXTENSION ".pas"
 
 typedef void (*UHFLoadingCallback)(void* context, bool state);
 
-// typedef struct {
-//     IclassEliteDict* dict;
-//     IclassEliteDictType type;
-//     uint8_t current_sector;
-// } IclassEliteDictAttackData;
-
-// typedef enum {
-//     PicopassDeviceEncryptionUnknown = 0,
-//     PicopassDeviceEncryptionNone = 0x14,
-//     PicopassDeviceEncryptionDES = 0x15,
-//     PicopassDeviceEncryption3DES = 0x17,
-// } PicopassEncryption;
-
-// typedef enum {
-//     PicopassDeviceSaveFormatHF,
-//     PicopassDeviceSaveFormatLF,
-// } PicopassDeviceSaveFormat;
-
-// typedef struct {
-//     bool valid;
-//     uint8_t bitLength;
-//     uint8_t FacilityCode;
-//     uint16_t CardNumber;
-// } PicopassWiegandRecord;
-
-// typedef struct {
-//     bool legacy;
-//     bool se_enabled;
-//     bool sio;
-//     bool biometrics;
-//     uint8_t key[8];
-//     bool elite_kdf;
-//     uint8_t pin_length;
-//     PicopassEncryption encryption;
-//     uint8_t credential[8];
-//     uint8_t pin0[8];
-//     uint8_t pin1[8];
-//     PicopassWiegandRecord record;
-// } PicopassPacs;
-
-// typedef struct {
-//     uint8_t data[PICOPASS_BLOCK_LEN];
-// } PicopassBlock;
-
-// typedef struct {
-//     PicopassBlock AA1[PICOPASS_MAX_APP_LIMIT];
-//     PicopassPacs pacs;
-//     IclassEliteDictAttackData iclass_elite_dict_attack_data;
-// } PicopassDeviceData;
-
 typedef struct {
     Storage* storage;
     DialogsApp* dialogs;
-    UHFResponseData* dev_data;
+    // UHFResponseData* dev_data;
+    UHFTag* uhf_tag;
     char dev_name[UHF_DEV_NAME_MAX_LEN + 1];
     FuriString* load_path;
     UHFLoadingCallback loading_cb;

uhf_worker.c

@@ -1,7 +1,7 @@
 #include "uhf_worker.h"
 #include "uhf_cmd.h"
 
-#define CB_DELAY 50
+#define CB_DELAY 75
 
 // uart callback functions
 void module_rx_callback(UartIrqEvent event, uint8_t data, void* ctx) {
@@ -45,42 +45,38 @@ UHFWorkerEvent verify_module_connected(UHFWorker* uhf_worker) {
     return UHFWorkerEventSuccess;
 }
 
-static bool send_set_select_command(UHFData* selected_tag) {
+static uint8_t get_epc_length_in_bits(uint8_t pc) {
+    uint8_t epc_length = pc;
+    epc_length >>= 3;
+    return (uint8_t)epc_length * 16; // x-words * 16 bits
+}
+
+static bool send_set_select_command(UHFData* selected_tag, UHFBank bank) {
     bool success = false;
-    uint16_t pc = 0;
-    uint16_t mask_length_bits = 0xF800;
-    size_t mask_length_word = 2;
     // Set select
     UHFData* select_cmd = uhf_data_alloc();
+    select_cmd->start = true;
     select_cmd->length = CMD_SET_SELECT_PARAMETER.length;
     memcpy((void*)&select_cmd->data, (void*)&CMD_SET_SELECT_PARAMETER.cmd[0], select_cmd->length);
-    pc += selected_tag->data[6];
-    pc <<= 8;
-    pc |= selected_tag->data[7];
-    mask_length_bits &= pc;
-    mask_length_bits >>= 11; // shift right 11 bits to only get 10h-14h
-    // mask length word
-    mask_length_word *= (size_t)(mask_length_bits);
-    // mask length in bits
-    mask_length_bits *= 16;
     // set select param
-    select_cmd->data[5] = 0x01; // 0x00=rfu, 0x01=epc, 0x10=tid, 0x11=user
+    size_t mask_length_bits = (size_t)get_epc_length_in_bits(selected_tag->data[6]);
+    size_t mask_length_bytes = (size_t)mask_length_bits / 8;
+    select_cmd->data[5] = bank; // 0x00=rfu, 0x01=epc, 0x10=tid, 0x11=user
     // set ptr
-    select_cmd->data[9] = 0x20;
+    select_cmd->data[9] = 0x20; // epc data begins after 0x20
     // set mask length
     select_cmd->data[10] = mask_length_bits;
     // set mask starting position
-    select_cmd->length = 11;
+    select_cmd->length = 12;
     // set mask
-    FURI_LOG_E("TAG", "Mask length (bits=%d, words=%d)", mask_length_bits, mask_length_word);
-    for(size_t i = 0; i < mask_length_word; i++) {
+    // FURI_LOG_E("TAG", "Mask length (bits=%d, bytes=%d)", mask_length_bits, mask_length_bytes);
+    for(size_t i = 0; i < mask_length_bytes; i++) {
         uhf_data_append(select_cmd, selected_tag->data[8 + i]);
     }
     uhf_data_append(select_cmd, 0x00); // add checksum section
     uhf_data_append(select_cmd, FRAME_END); // command end
     // add checksum
     select_cmd->data[select_cmd->length - 2] = uhf_data_calculate_checksum(select_cmd);
-
     UHFData* select_response = uhf_data_alloc();
     furi_hal_uart_set_irq_cb(FuriHalUartIdUSART1, module_rx_callback, select_response);
     furi_hal_uart_tx(FuriHalUartIdUSART1, select_cmd->data, select_cmd->length);
@@ -134,7 +130,12 @@ UHFWorkerEvent read_single_card(UHFWorker* uhf_worker) {
         }
     }
 
-    if(!send_set_select_command(raw_read_data)) return UHFWorkerEventFail;
+    // todo : rfu ?
+    UHFTag* uhf_tag = uhf_worker->uhf_tag;
+    // add to tag object
+    UHFData* raw_bank_data = uhf_data_alloc();
+    size_t epc_length = (size_t)get_epc_length_in_bits(raw_read_data->data[6]) / 8;
+    size_t offset = (size_t)(6 + epc_length);
 
     UHFData* read_bank_cmd = uhf_data_alloc();
     read_bank_cmd->length = CMD_READ_LABEL_DATA_STORAGE.length;
@@ -143,60 +144,30 @@ UHFWorkerEvent read_single_card(UHFWorker* uhf_worker) {
         (void*)&CMD_READ_LABEL_DATA_STORAGE.cmd[0],
         read_bank_cmd->length);
 
-    // int retry = 10;
-    // read rfu bank
-    UHFData* rfu_bank = uhf_response_data_add_new_uhf_data(uhf_response_data);
-    if(!read_bank(read_bank_cmd, rfu_bank, RFU_BANK)) {
-        uhf_data_reset(rfu_bank);
-    }
+    send_set_select_command(raw_read_data, EPC_BANK);
 
-    // read epc bank
-    UHFData* epc_bank = uhf_response_data_add_new_uhf_data(uhf_response_data);
-    if(!read_bank(read_bank_cmd, epc_bank, EPC_BANK)) {
-        uhf_data_reset(epc_bank);
-    }
+    do {
+        if(!read_bank(read_bank_cmd, raw_bank_data, EPC_BANK)) break;
+        uhf_tag_set_epc(uhf_tag, raw_bank_data->data + offset, epc_length);
+        uhf_data_reset(raw_bank_data);
+    } while(0);
 
-    // read tid bank
-    UHFData* tid_bank = uhf_response_data_add_new_uhf_data(uhf_response_data);
-    if(!read_bank(read_bank_cmd, tid_bank, TID_BANK)) {
-        uhf_data_reset(tid_bank);
-    }
+    do {
+        if(!read_bank(read_bank_cmd, raw_bank_data, TID_BANK)) break;
+        uhf_tag_set_tid(uhf_tag, raw_bank_data->data + offset, 12);
+        uhf_data_reset(raw_bank_data);
+    } while(0);
 
-    // read user bank
-    UHFData* user_bank = uhf_response_data_add_new_uhf_data(uhf_response_data);
-    if(!read_bank(read_bank_cmd, user_bank, USER_BANK)) {
-        uhf_data_reset(user_bank);
-    }
+    do {
+        if(!read_bank(read_bank_cmd, raw_bank_data, USER_BANK)) break;
+        uhf_tag_set_tid(uhf_tag, raw_bank_data->data + offset, 12);
+        uhf_data_reset(raw_bank_data);
+    } while(0);
 
-    // FuriString* str;
-    // str = furi_string_alloc();
-    // furi_string_cat(str, "RFU : ");
-    // for(int i = 0; i < (int)rfu_bank->length; i++) {
-    //     furi_string_cat_printf(str, "%02x ", rfu_bank->data[i]);
-    // }
-    // FURI_LOG_E("TAG", furi_string_get_cstr(str));
-    // furi_string_reset(str);
-    // furi_string_cat(str, "EPC : ");
-    // for(int i = 0; i < (int)epc_bank->length; i++) {
-    //     furi_string_cat_printf(str, "%02x ", epc_bank->data[i]);
-    // }
-    // FURI_LOG_E("TAG", furi_string_get_cstr(str));
-    // furi_string_reset(str);
-    // furi_string_cat(str, "TID : ");
-    // for(int i = 0; i < (int)tid_bank->length; i++) {
-    //     furi_string_cat_printf(str, "%02x ", tid_bank->data[i]);
-    // }
-    // FURI_LOG_E("TAG", furi_string_get_cstr(str));
-    // furi_string_reset(str);
-    // furi_string_cat(str, "USER : ");
-    // for(int i = 0; i < (int)user_bank->length; i++) {
-    //     furi_string_cat_printf(str, "%02x ", user_bank->data[i]);
-    // }
-    // FURI_LOG_E("TAG", furi_string_get_cstr(str));
-    // furi_string_reset(str);
+    uhf_data_free(raw_bank_data);
+    uhf_data_free(read_bank_cmd);
     furi_string_free(temp_str);
 
-    uhf_data_free(read_bank_cmd);
     return UHFWorkerEventSuccess;
 }
 

uhf_worker.h

@@ -31,6 +31,7 @@ typedef void (*UHFWorkerCallback)(UHFWorkerEvent event, void* ctx);
 typedef struct UHFWorker {
     FuriThread* thread;
     UHFResponseData* response_data;
+    UHFTag* uhf_tag;
     UHFWorkerCallback callback;
     UHFWorkerState state;
     void* ctx;