upd uhf rfid

scenes/uhf_scene_device_info.c

@@ -1,7 +1,11 @@
 #include "../uhf_app_i.h"
 #include <dolphin/dolphin.h>
 
-typedef enum { EPC_INFO, TID_INFO, USER_INFO } UHFTagInfo;
+typedef enum {
+    EPC_INFO,
+    TID_INFO,
+    USER_INFO
+} UHFTagInfo;
 
 static UHFTagInfo current_info;
 

scenes/uhf_scene_module_info.c

@@ -144,4 +144,4 @@ void uhf_scene_module_info_on_exit(void* ctx) {
     uhf_worker_stop(uhf_app->worker);
     // clear widget
     widget_reset(uhf_app->widget);
-}
+}

scenes/uhf_scene_read_tag_success.c

@@ -108,4 +108,4 @@ void uhf_scene_read_tag_success_on_exit(void* ctx) {
     popup_reset(uhf_app->popup);
     // clear widget
     widget_reset(uhf_app->widget);
-}
+}

scenes/uhf_scene_save_name.c

@@ -1,5 +1,5 @@
 #include "../uhf_app_i.h"
-#include <toolbox/name_generator.h>
+#include <lib/toolbox/name_generator.h>
 #include <gui/modules/validators.h>
 #include <toolbox/path.h>
 
@@ -14,9 +14,7 @@ void uhf_scene_save_name_on_enter(void* context) {
 
     // Setup view
     TextInput* text_input = uhf_app->text_input;
-
     name_generator_make_auto(uhf_app->text_store, sizeof(uhf_app->text_store), "UHF");
-
     text_input_set_header_text(text_input, "Name the tag");
     text_input_set_result_callback(
         text_input,

scenes/uhf_scene_settings.c

@@ -1,6 +1,8 @@
 #include "../uhf_app_i.h"
 #include "../uhf_module.h"
 
+char* yes_no[] = {"No", "Yes"};
+
 void uhf_settings_set_module_baudrate(VariableItem* item) {
     M100Module* module = variable_item_get_context(item);
     uint8_t index = variable_item_get_current_value_index(item);
@@ -38,6 +40,50 @@ void uhf_settings_set_module_working_region(VariableItem* item) {
     variable_item_set_current_value_text(item, WORKING_REGIONS_STR[index]);
 }
 
+void uhf_settings_set_epc_write_mask(VariableItem* item) {
+    M100Module* uhf_module = variable_item_get_context(item);
+    uint8_t index = variable_item_get_current_value_index(item);
+    variable_item_set_current_value_text(item, yes_no[index]);
+    if(index) {
+        m100_enable_write_mask(uhf_module, WRITE_EPC);
+        return;
+    }
+    m100_disable_write_mask(uhf_module, WRITE_EPC);
+}
+
+void uhf_settings_set_tid_write_mask(VariableItem* item) {
+    M100Module* uhf_module = variable_item_get_context(item);
+    uint8_t index = variable_item_get_current_value_index(item);
+    variable_item_set_current_value_text(item, yes_no[index]);
+    if(index) {
+        m100_enable_write_mask(uhf_module, WRITE_TID);
+        return;
+    }
+    m100_disable_write_mask(uhf_module, WRITE_TID);
+}
+
+void uhf_settings_set_user_write_mask(VariableItem* item) {
+    M100Module* uhf_module = variable_item_get_context(item);
+    uint8_t index = variable_item_get_current_value_index(item);
+    variable_item_set_current_value_text(item, yes_no[index]);
+    if(index) {
+        m100_enable_write_mask(uhf_module, WRITE_USER);
+        return;
+    }
+    m100_disable_write_mask(uhf_module, WRITE_USER);
+}
+
+void uhf_settings_set_rfu_write_mask(VariableItem* item) {
+    M100Module* uhf_module = variable_item_get_context(item);
+    uint8_t index = variable_item_get_current_value_index(item);
+    variable_item_set_current_value_text(item, yes_no[index]);
+    if(index) {
+        m100_enable_write_mask(uhf_module, WRITE_RFU);
+        return;
+    }
+    m100_disable_write_mask(uhf_module, WRITE_RFU);
+}
+
 uint8_t uhf_settings_get_module_baudrate_index(M100Module* module) {
     for(uint8_t i = 0; i < BAUD_RATES_COUNT; i++) {
         if(BAUD_RATES[i] == module->uart->baudrate) {
@@ -71,6 +117,7 @@ void uhf_scene_settings_on_enter(void* ctx) {
     VariableItem* item;
     VariableItemList* variable_item_list = uhf_app->variable_item_list;
 
+    // Add baudrate item
     uint8_t value_index = uhf_settings_get_module_baudrate_index(uhf_module);
     char text_buf[10];
     snprintf(text_buf, sizeof(text_buf), "%lu", uhf_module->uart->baudrate);
@@ -84,6 +131,7 @@ void uhf_scene_settings_on_enter(void* ctx) {
     variable_item_set_current_value_text(item, text_buf);
     variable_item_set_current_value_index(item, value_index);
 
+    // Add power item
     value_index = uhf_settings_get_module_power_index(uhf_module);
     item = variable_item_list_add(
         variable_item_list,
@@ -95,6 +143,7 @@ void uhf_scene_settings_on_enter(void* ctx) {
     variable_item_set_current_value_text(item, text_buf);
     variable_item_set_current_value_index(item, value_index);
 
+    // Add working region item
     value_index = uhf_settings_get_module_working_region_index(uhf_module);
     item = variable_item_list_add(
         variable_item_list,
@@ -106,6 +155,31 @@ void uhf_scene_settings_on_enter(void* ctx) {
     variable_item_set_current_value_index(item, value_index);
 
     view_dispatcher_switch_to_view(uhf_app->view_dispatcher, UHFViewVariableItemList);
+
+    // Add write modes
+    value_index = m100_is_write_mask_enabled(uhf_module, WRITE_EPC) ? 1 : 0;
+    item = variable_item_list_add(
+        variable_item_list, "Write EPC:", 2, uhf_settings_set_epc_write_mask, uhf_module);
+    variable_item_set_current_value_text(item, yes_no[value_index]);
+    variable_item_set_current_value_index(item, value_index);
+
+    value_index = m100_is_write_mask_enabled(uhf_module, WRITE_TID) ? 1 : 0;
+    item = variable_item_list_add(
+        variable_item_list, "Write TID:", 2, uhf_settings_set_tid_write_mask, uhf_module);
+    variable_item_set_current_value_text(item, yes_no[value_index]);
+    variable_item_set_current_value_index(item, value_index);
+
+    value_index = m100_is_write_mask_enabled(uhf_module, WRITE_USER) ? 1 : 0;
+    item = variable_item_list_add(
+        variable_item_list, "Write User:", 2, uhf_settings_set_user_write_mask, uhf_module);
+    variable_item_set_current_value_text(item, yes_no[value_index]);
+    variable_item_set_current_value_index(item, value_index);
+
+    value_index = m100_is_write_mask_enabled(uhf_module, WRITE_RFU) ? 1 : 0;
+    item = variable_item_list_add(
+        variable_item_list, "Write RFU:", 2, uhf_settings_set_rfu_write_mask, uhf_module);
+    variable_item_set_current_value_text(item, yes_no[value_index]);
+    variable_item_set_current_value_index(item, value_index);
 }
 
 bool uhf_scene_settings_on_event(void* ctx, SceneManagerEvent event) {
@@ -119,4 +193,4 @@ void uhf_scene_settings_on_exit(void* ctx) {
     UHFApp* uhf_app = ctx;
     variable_item_list_set_selected_item(uhf_app->variable_item_list, 0);
     variable_item_list_reset(uhf_app->variable_item_list);
-}
+}

scenes/uhf_scene_start.c

@@ -1,6 +1,10 @@
 #include "../uhf_app_i.h"
 
-enum SubmenuIndex { SubmenuIndexRead, SubmenuIndexSaved, SubmenuIndexSettings };
+enum SubmenuIndex {
+    SubmenuIndexRead,
+    SubmenuIndexSaved,
+    SubmenuIndexSettings
+};
 
 void uhf_scene_start_submenu_callback(void* ctx, uint32_t index) {
     UHFApp* uhf_app = ctx;
@@ -51,4 +55,4 @@ bool uhf_scene_start_on_event(void* ctx, SceneManagerEvent event) {
 void uhf_scene_start_on_exit(void* ctx) {
     UHFApp* uhf_app = ctx;
     submenu_reset(uhf_app->submenu);
-}
+}

scenes/uhf_scene_write_tag_success.c

@@ -91,4 +91,4 @@ void uhf_scene_write_tag_success_on_exit(void* ctx) {
     popup_reset(uhf_app->popup);
     // clear widget
     widget_reset(uhf_app->widget);
-}
+}

uhf_app.c

@@ -1,5 +1,5 @@
 #include "uhf_app_i.h"
-#include <expansion/expansion.h>
+#include "expansion/expansion.h"
 
 char* convertToHexString(uint8_t* array, size_t length) {
     if(array == NULL || length == 0) {
@@ -110,10 +110,6 @@ UHFApp* uhf_alloc() {
 void uhf_free(UHFApp* uhf_app) {
     furi_assert(uhf_app);
 
-    // Variable Item List
-    view_dispatcher_remove_view(uhf_app->view_dispatcher, UHFViewVariableItemList);
-    variable_item_list_free(uhf_app->variable_item_list);
-
     // Submenu
     view_dispatcher_remove_view(uhf_app->view_dispatcher, UHFViewMenu);
     submenu_free(uhf_app->submenu);
@@ -134,6 +130,10 @@ void uhf_free(UHFApp* uhf_app) {
     view_dispatcher_remove_view(uhf_app->view_dispatcher, UHFViewWidget);
     widget_free(uhf_app->widget);
 
+    // Variable Item List
+    view_dispatcher_remove_view(uhf_app->view_dispatcher, UHFViewVariableItemList);
+    variable_item_list_free(uhf_app->variable_item_list);
+
     // Tag
     uhf_tag_wrapper_free(uhf_app->worker->uhf_tag_wrapper);
 
@@ -195,32 +195,25 @@ void uhf_show_loading_popup(void* ctx, bool show) {
 
 int32_t uhf_app_main(void* ctx) {
     UNUSED(ctx);
-
-    // Disable expansion protocol to avoid interference with UART Handle
     Expansion* expansion = furi_record_open(RECORD_EXPANSION);
     expansion_disable(expansion);
-
-    UHFApp* uhf_app = uhf_alloc();
-    // enable 5v pin
-    uint8_t attempts = 0;
-    bool otg_was_enabled = furi_hal_power_is_otg_enabled();
-    while(!furi_hal_power_is_otg_enabled() && attempts++ < 5) {
+    bool is_5v_enabled_by_app = false;
+    // enable 5v pin if not enabled
+    if(!furi_hal_power_is_otg_enabled()) {
         furi_hal_power_enable_otg();
-        furi_delay_ms(10);
+        is_5v_enabled_by_app = true;
     }
+    UHFApp* uhf_app = uhf_alloc();
     // enter app
     scene_manager_next_scene(uhf_app->scene_manager, UHFSceneModuleInfo);
     view_dispatcher_run(uhf_app->view_dispatcher);
-    // disable 5v pin
-    if(furi_hal_power_is_otg_enabled() && !otg_was_enabled) {
+    // disable 5v pin if enabled by app
+    if(is_5v_enabled_by_app) {
         furi_hal_power_disable_otg();
     }
     // exit app
     uhf_free(uhf_app);
-
-    // Return previous state of expansion
     expansion_enable(expansion);
     furi_record_close(RECORD_EXPANSION);
-
     return 0;
-}
+}

uhf_buffer.c

@@ -11,40 +11,39 @@ Buffer* uhf_buffer_alloc(size_t initial_capacity) {
     }
     buf->size = 0;
     buf->capacity = initial_capacity;
+    buf->head = 0;
+    buf->tail = 0;
     return buf;
 }
 
 bool uhf_buffer_append_single(Buffer* buf, uint8_t data) {
     if(buf->closed) return false;
-    if(buf->size + 1 > buf->capacity) {
-        size_t new_capacity = buf->capacity * 2;
-        uint8_t* new_data = (uint8_t*)realloc(buf->data, sizeof(uint8_t) * new_capacity);
-        if(!new_data) return false;
-        buf->data = new_data;
-        buf->capacity = new_capacity;
+    buf->data[buf->tail] = data;
+    buf->tail = (buf->tail + 1) % buf->capacity;
+    if(buf->size < buf->capacity) {
+        buf->size++;
+    } else {
+        buf->head = (buf->head + 1) % buf->capacity;
     }
-    buf->data[buf->size++] = data;
     return true;
 }
 
 bool uhf_buffer_append(Buffer* buf, uint8_t* data, size_t data_size) {
     if(buf->closed) return false;
-    if(buf->size + data_size > buf->capacity) {
-        size_t new_capacity = buf->capacity * 2;
-        uint8_t* new_data = (uint8_t*)realloc(buf->data, new_capacity);
-        if(!new_data) return false;
-
-        buf->data = new_data;
-        buf->capacity = new_capacity;
+    for(size_t i = 0; i < data_size; i++) {
+        buf->data[buf->tail] = data[i];
+        buf->tail = (buf->tail + 1) % buf->capacity;
+        if(buf->size < buf->capacity) {
+            buf->size++;
+        } else {
+            buf->head = (buf->head + 1) % buf->capacity;
+        }
     }
-
-    memcpy((void*)&buf->data[buf->size], data, data_size);
-    buf->size += data_size;
     return true;
 }
 
 uint8_t* uhf_buffer_get_data(Buffer* buf) {
-    return buf->data;
+    return &buf->data[buf->head];
 }
 
 size_t uhf_buffer_get_size(Buffer* buf) {
@@ -60,9 +59,8 @@ void uhf_buffer_close(Buffer* buf) {
 }
 
 void uhf_buffer_reset(Buffer* buf) {
-    for(size_t i = 0; i < MAX_BUFFER_SIZE; i++) {
-        buf->data[i] = 0;
-    }
+    buf->head = 0;
+    buf->tail = 0;
     buf->size = 0;
     buf->closed = false;
 }
@@ -70,4 +68,4 @@ void uhf_buffer_reset(Buffer* buf) {
 void uhf_buffer_free(Buffer* buf) {
     free(buf->data);
     free(buf);
-}
+}

uhf_buffer.h

@@ -5,10 +5,12 @@
 
 #define MAX_BUFFER_SIZE 200
 
-typedef struct Buffer {
+typedef struct {
     uint8_t* data;
     size_t size;
     size_t capacity;
+    size_t head;
+    size_t tail;
     bool closed;
 } Buffer;
 
@@ -21,4 +23,4 @@ size_t uhf_buffer_get_size(Buffer* buf);
 bool uhf_is_buffer_closed(Buffer* buf);
 void uhf_buffer_close(Buffer* buf);
 void uhf_buffer_reset(Buffer* buf);
-void uhf_buffer_free(Buffer* buf);
+void uhf_buffer_free(Buffer* buf);

uhf_device.c

@@ -244,4 +244,4 @@ void uhf_device_set_loading_callback(UHFDevice* dev, UHFLoadingCallback callback
 
     dev->loading_cb = callback;
     dev->loading_cb_ctx = context;
-}
+}

uhf_device.h

@@ -7,16 +7,16 @@
 #include <mbedtls/des.h>
 #include "uhf_tag.h"
 
-#define UHF_DEV_NAME_MAX_LEN 22
-#define UHF_EPC_BANK_LENGTH_LABEL "EPC_LENGTH"
-#define UHF_TID_BANK_LENGTH_LABEL "TID_LENGTH"
+#define UHF_DEV_NAME_MAX_LEN       22
+#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_EPC_PC_LABEL "PC"
-#define UHF_EPC_CRC_LABEL "CRC"
-#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_EPC_PC_LABEL           "PC"
+#define UHF_EPC_CRC_LABEL          "CRC"
+#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"
 

uhf_module.c

@@ -1,7 +1,7 @@
 #include "uhf_module.h"
 #include "uhf_module_cmd.h"
 
-#define DELAY_MS 100
+#define DELAY_MS  100
 #define WAIT_TICK 4000 // max wait time in between each byte
 
 static M100ResponseType setup_and_send_rx(M100Module* module, uint8_t* cmd, size_t cmd_length) {
@@ -46,6 +46,7 @@ M100Module* m100_module_alloc() {
     module->region = DEFAULT_WORKING_REGION;
     module->info = m100_module_info_alloc();
     module->uart = uhf_uart_alloc();
+    module->write_mask = WRITE_EPC; // default to write epc only
     return module;
 }
 
@@ -183,6 +184,18 @@ M100ResponseType m100_set_select(M100Module* module, UHFTag* uhf_tag) {
     return M100SuccessResponse;
 }
 
+void m100_enable_write_mask(M100Module* module, WriteMask mask) {
+    module->write_mask |= mask;
+}
+
+void m100_disable_write_mask(M100Module* module, WriteMask mask) {
+    module->write_mask &= ~mask;
+}
+
+bool m100_is_write_mask_enabled(M100Module* module, WriteMask mask) {
+    return (module->write_mask & mask) == mask;
+}
+
 UHFTag* m100_get_select_param(M100Module* module) {
     uhf_buffer_reset(module->uart->buffer);
     // furi_hal_uart_set_irq_cb(FuriHalUartIdLPUART1, rx_callback, module->uart->buffer);
@@ -369,4 +382,4 @@ bool m100_set_power(M100Module* module, uint8_t* power) {
 
 uint32_t m100_get_baudrate(M100Module* module) {
     return module->uart->baudrate;
-}
+}

uhf_module.h

@@ -8,11 +8,11 @@
 #include "uhf_buffer.h"
 #include "uhf_module_settings.h"
 
-#define FRAME_START 0xBB
-#define FRAME_END 0x7E
-#define DEFAULT_BAUDRATE BAUD_RATES[BAUD_RATES_COUNT - 1]
+#define FRAME_START                0xBB
+#define FRAME_END                  0x7E
+#define DEFAULT_BAUDRATE           BAUD_RATES[BAUD_RATES_COUNT - 1]
 #define DEFAULT_TRANSMITTING_POWER POWER_DBM[POWER_DBM_COUNT - 1]
-#define DEFAULT_WORKING_REGION WR_US
+#define DEFAULT_WORKING_REGION     WR_US
 
 typedef struct {
     char* hw_version;
@@ -29,12 +29,20 @@ typedef enum {
     M100ChecksumFail
 } M100ResponseType;
 
+typedef enum {
+    WRITE_EPC = 1 << 0,
+    WRITE_TID = 1 << 1,
+    WRITE_USER = 1 << 2,
+    WRITE_RFU = 1 << 3
+} WriteMask;
+
 typedef struct {
     M100ModuleInfo* info;
     WorkingRegion region;
     uint16_t region_frequency;
     uint16_t transmitting_power;
     uint16_t max_transmitting_power;
+    uint16_t write_mask;
     bool freq_hopping;
     UHFUart* uart;
 } M100Module;
@@ -78,3 +86,6 @@ M100ResponseType m100_write_label_data_storage(
     uint32_t access_pwd);
 
 uint32_t m100_get_baudrate(M100Module* module);
+void m100_enable_write_mask(M100Module* module, WriteMask mask);
+void m100_disable_write_mask(M100Module* module, WriteMask mask);
+bool m100_is_write_mask_enabled(M100Module* module, WriteMask mask);

uhf_tag.h

@@ -4,9 +4,14 @@
 #include <stdbool.h>
 #include <stddef.h>
 
-#define MAX_BANK_SIZE 256
+#define MAX_BANK_SIZE 200
 // storage enum
-typedef enum { ReservedBank, EPCBank, TIDBank, UserBank } BankType;
+typedef enum {
+    ReservedBank,
+    EPCBank,
+    TIDBank,
+    UserBank
+} BankType;
 
 // Reserved Memory Bank
 typedef struct {

uhf_tag_i.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <stdint.h>
+#include <stddef.h>
+
+typedef enum {
+    MANUFACTURER_UNKNOWN = 0,
+    MANUFACTURER_ALIEN,
+    MANUFACTURER_IMPINJ,
+    MANUFACTURER_NXP,
+} Manufacturer;
+
+typedef enum {
+    TAG_TYPE_UNKNOWN = 0,
+    TAG_TYPE_EPC_CLASS1_GEN2,
+    TAG_TYPE_ISO18000_6C,
+} TagType;
+
+typedef enum {
+    TAG_PROTOCOL_UNKNOWN = 0,
+    TAG_PROTOCOL_GEN2,
+    TAG_PROTOCOL_ISO18000_6C,
+} TagProtocol;
+
+typedef enum {
+    TAG_MEMORY_UNKNOWN = 0,
+    TAG_MEMORY_EPC,
+    TAG_MEMORY_TID,
+    TAG_MEMORY_USER,
+} TagMemory;
+
+typedef enum {
+    TAG_LOCK_UNKNOWN = 0,
+    TAG_LOCK_UNLOCKED,
+    TAG_LOCK_LOCKED,
+} TagLock;
+
+typedef enum {
+    TAG_KILL_UNKNOWN = 0,
+    TAG_KILL_UNLOCKED,
+    TAG_KILL_LOCKED,
+} TagKill;
+
+typedef enum {
+    TAG_PASSWORD_UNKNOWN = 0,
+    TAG_PASSWORD_UNLOCKED,
+    TAG_PASSWORD_LOCKED,
+} TagPassword;
+
+typedef enum {
+    TAG_EAS_UNKNOWN = 0,
+    TAG_EAS_DISABLED,
+    TAG_EAS_ENABLED,
+} TagEAS;

uhf_uart.c

@@ -61,14 +61,12 @@ UHFUart* uhf_uart_alloc() {
     UHFUart* uart = (UHFUart*)malloc(sizeof(UHFUart));
     uart->bus = FuriHalBusUSART1;
     uart->handle = furi_hal_serial_control_acquire(FuriHalSerialIdUsart);
-    // uart->rx_buff_stream = furi_stream_buffer_alloc(UHF_UART_RX_BUFFER_SIZE, 1);
+    furi_check(uart->handle, "UHF UART HANDLE IS NULL");
     uart->tick = UHF_UART_WAIT_TICK;
     uart->baudrate = UHF_UART_DEFAULT_BAUDRATE;
     // expansion_disable -> is done at app start already
     furi_hal_serial_init(uart->handle, uart->baudrate);
     uart->buffer = uhf_buffer_alloc(UHF_UART_RX_BUFFER_SIZE);
-    // uart->thread = furi_thread_alloc_ex("UHFUartWorker", UHF_UART_WORKER_STACK_SIZE, uhf_uart_worker_callback, uart);
-    // furi_thread_start(uart->thread);
     furi_hal_serial_async_rx_start(uart->handle, uhf_uart_default_rx_callback, uart, false);
     return uart;
 }
@@ -120,4 +118,4 @@ bool uhf_uart_tick(UHFUart* uart) {
 
 void uhf_uart_tick_reset(UHFUart* uart) {
     uart->tick = UHF_UART_WAIT_TICK;
-}
+}

uhf_uart.h

@@ -5,12 +5,12 @@
 #include <stdbool.h>
 #include "uhf_buffer.h"
 
-#define UHF_UART_RX_BUFFER_SIZE 250
+#define UHF_UART_RX_BUFFER_SIZE   250
 // #define UHF_UART_WORKER_STACK_SIZE 1 * 1024
 #define UHF_UART_DEFAULT_BAUDRATE 115200
-#define UHF_UART_FRAME_START 0xBB
-#define UHF_UART_FRAME_END 0x7E
-#define UHF_UART_WAIT_TICK 1000
+#define UHF_UART_FRAME_START      0xBB
+#define UHF_UART_FRAME_END        0x7E
+#define UHF_UART_WAIT_TICK        1000
 
 typedef void (*CallbackFunction)(uint8_t* data, void* ctx);
 

uhf_worker.c

@@ -70,18 +70,24 @@ UHFWorkerEvent write_single_card(UHFWorker* uhf_worker) {
         if(uhf_worker->state == UHFWorkerStateStop) return UHFWorkerEventAborted;
         if(rp_type == M100SuccessResponse) break;
     } while(true);
-    do {
+    while(m100_is_write_mask_enabled(uhf_worker->module, WRITE_USER)) {
         rp_type = m100_write_label_data_storage(
             uhf_worker->module, uhf_tag_from, uhf_tag_des, UserBank, 0, 0);
         if(uhf_worker->state == UHFWorkerStateStop) return UHFWorkerEventAborted;
         if(rp_type == M100SuccessResponse) break;
-    } while(true);
-    do {
+    }
+    while(m100_is_write_mask_enabled(uhf_worker->module, WRITE_TID)) {
+        rp_type = m100_write_label_data_storage(
+            uhf_worker->module, uhf_tag_from, uhf_tag_des, TIDBank, 0, 0);
+        if(uhf_worker->state == UHFWorkerStateStop) return UHFWorkerEventAborted;
+        if(rp_type == M100SuccessResponse) break;
+    }
+    while(m100_is_write_mask_enabled(uhf_worker->module, WRITE_EPC)) {
         rp_type = m100_write_label_data_storage(
             uhf_worker->module, uhf_tag_from, uhf_tag_des, EPCBank, 0, 0);
         if(uhf_worker->state == UHFWorkerStateStop) return UHFWorkerEventAborted;
         if(rp_type == M100SuccessResponse) break;
-    } while(true);
+    }
     return UHFWorkerEventSuccess;
 }
 
@@ -140,4 +146,4 @@ void uhf_worker_free(UHFWorker* uhf_worker) {
     furi_thread_free(uhf_worker->thread);
     m100_module_free(uhf_worker->module);
     free(uhf_worker);
-}
+}

uhf_worker.h

@@ -48,4 +48,4 @@ void uhf_worker_start(
     UHFWorkerCallback callback,
     void* ctx);
 void uhf_worker_stop(UHFWorker* uhf_worker);
-void uhf_worker_free(UHFWorker* uhf_worker);
+void uhf_worker_free(UHFWorker* uhf_worker);