inital commit to add write tag

scenes/uhf_scene_config.h

@@ -2,7 +2,7 @@ ADD_SCENE(uhf, verify, Verify)
 ADD_SCENE(uhf, start, Start)
 ADD_SCENE(uhf, read_tag, ReadTag)
 ADD_SCENE(uhf, read_tag_success, ReadTagSuccess)
-ADD_SCENE(uhf, card_menu, CardMenu)
+ADD_SCENE(uhf, tag_menu, TagMenu)
 ADD_SCENE(uhf, save_name, SaveName)
 ADD_SCENE(uhf, save_success, SaveSuccess)
 ADD_SCENE(uhf, saved_menu, SavedMenu)
@@ -10,8 +10,8 @@ ADD_SCENE(uhf, file_select, FileSelect)
 ADD_SCENE(uhf, device_info, DeviceInfo)
 ADD_SCENE(uhf, delete, Delete)
 ADD_SCENE(uhf, delete_success, DeleteSuccess)
-// ADD_SCENE(uhf, write_card, WriteCard)
-// ADD_SCENE(uhf, write_card_success, WriteCardSuccess)
+ADD_SCENE(uhf, write_card, WriteCard)
+ADD_SCENE(uhf, write_card_success, WriteCardSuccess)
 // ADD_SCENE(uhf, read_factory_success, ReadFactorySuccess)
 // ADD_SCENE(uhf, write_key, WriteKey)
 // ADD_SCENE(uhf, key_menu, KeyMenu)

scenes/uhf_scene_read_tag_success.c

@@ -72,7 +72,7 @@ bool uhf_scene_read_tag_success_on_event(void* ctx, SceneManagerEvent event) {
             consumed = scene_manager_search_and_switch_to_previous_scene(
                 uhf_app->scene_manager, UHFSceneStart);
         } else if(event.event == GuiButtonTypeRight) {
-            scene_manager_next_scene(uhf_app->scene_manager, UHFSceneCardMenu);
+            scene_manager_next_scene(uhf_app->scene_manager, UHFSceneTagMenu);
             consumed = true;
         } else if(event.event == GuiButtonTypeCenter) {
             // consumed = scene_manager_search_and_switch_to_another_scene(

scenes/uhf_scene_save_success.c

@@ -27,9 +27,9 @@ bool uhf_scene_save_success_on_event(void* context, SceneManagerEvent event) {
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == UHFCustomEventViewExit) {
-            if(scene_manager_has_previous_scene(uhf_app->scene_manager, UHFSceneCardMenu)) {
+            if(scene_manager_has_previous_scene(uhf_app->scene_manager, UHFSceneTagMenu)) {
                 consumed = scene_manager_search_and_switch_to_previous_scene(
-                    uhf_app->scene_manager, UHFSceneCardMenu);
+                    uhf_app->scene_manager, UHFSceneTagMenu);
             } else {
                 consumed = scene_manager_search_and_switch_to_previous_scene(
                     uhf_app->scene_manager, UHFSceneStart);

scenes/uhf_scene_card_menu.c → scenes/uhf_scene_tag_menu.c

@@ -5,45 +5,41 @@ enum SubmenuIndex {
     SubmenuIndexChangeKey,
 };
 
-void uhf_scene_card_menu_submenu_callback(void* ctx, uint32_t index) {
+void uhf_scene_tag_menu_submenu_callback(void* ctx, uint32_t index) {
     UHFApp* uhf_app = ctx;
     view_dispatcher_send_custom_event(uhf_app->view_dispatcher, index);
 }
 
-void uhf_scene_card_menu_on_enter(void* ctx) {
+void uhf_scene_tag_menu_on_enter(void* ctx) {
     UHFApp* uhf_app = ctx;
 
     Submenu* submenu = uhf_app->submenu;
 
     submenu_add_item(
-        submenu, "Save", SubmenuIndexSave, uhf_scene_card_menu_submenu_callback, uhf_app);
+        submenu, "Save", SubmenuIndexSave, uhf_scene_tag_menu_submenu_callback, uhf_app);
     submenu_add_item(
-        submenu,
-        "Change Key",
-        SubmenuIndexChangeKey,
-        uhf_scene_card_menu_submenu_callback,
-        uhf_app);
+        submenu, "Change Key", SubmenuIndexChangeKey, uhf_scene_tag_menu_submenu_callback, uhf_app);
 
     submenu_set_selected_item(
-        submenu, scene_manager_get_scene_state(uhf_app->scene_manager, UHFSceneCardMenu));
+        submenu, scene_manager_get_scene_state(uhf_app->scene_manager, UHFSceneTagMenu));
 
     view_dispatcher_switch_to_view(uhf_app->view_dispatcher, UHFViewMenu);
 }
 
-bool uhf_scene_card_menu_on_event(void* ctx, SceneManagerEvent event) {
+bool uhf_scene_tag_menu_on_event(void* ctx, SceneManagerEvent event) {
     UHFApp* uhf_app = ctx;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == SubmenuIndexSave) {
             scene_manager_set_scene_state(
-                uhf_app->scene_manager, UHFSceneCardMenu, SubmenuIndexSave);
+                uhf_app->scene_manager, UHFSceneTagMenu, SubmenuIndexSave);
             scene_manager_next_scene(uhf_app->scene_manager, UHFSceneSaveName);
             consumed = true;
         }
         // else if(event.event == SubmenuIndexChangeKey) {
         //     scene_manager_set_scene_state(
-        //         picopass->scene_manager, UHFSceneCardMenu, SubmenuIndexChangeKey);
+        //         picopass->scene_manager, UHFSceneTagMenu, SubmenuIndexChangeKey);
         //     scene_manager_next_scene(picopass->scene_manager, PicopassSceneKeyMenu);
         //     consumed = true;
         // }
@@ -55,7 +51,7 @@ bool uhf_scene_card_menu_on_event(void* ctx, SceneManagerEvent event) {
     return consumed;
 }
 
-void uhf_scene_card_menu_on_exit(void* ctx) {
+void uhf_scene_tag_menu_on_exit(void* ctx) {
     UHFApp* uhf_app = ctx;
 
     submenu_reset(uhf_app->submenu);

scenes/uhf_scene_write_tag.c

@@ -0,0 +1,49 @@
+#include "../uhf_app_i.h"
+#include <dolphin/dolphin.h>
+
+void uhf_write_tag_worker_callback(UHFWorkerEvent event, void* ctx) {
+    UHFApp* uhf_app = ctx;
+    if(event == UHFWorkerEventSuccess) {
+        view_dispatcher_send_custom_event(uhf_app->view_dispatcher, UHFCustomEventWorkerExit);
+    }
+    // } else if(event == UHFWorkerEventAborted) {
+    //     scene_manager_search_and_switch_to_previous_scene(uhf_app->scene_manager, UHFSceneStart);
+    // }
+}
+
+void uhf_scene_write_tag_on_enter(void* ctx) {
+    UHFApp* uhf_app = ctx;
+    dolphin_deed(DolphinDeedNfcRead);
+
+    // Setup view
+    Popup* popup = uhf_app->popup;
+    popup_set_header(popup, "Writing\n[UHF] RFID\nTag", 68, 30, AlignLeft, AlignTop);
+    popup_set_icon(popup, 0, 3, &I_RFIDDolphinSend_97x61);
+
+    // Start worker
+    view_dispatcher_switch_to_view(uhf_app->view_dispatcher, UHFViewPopup);
+    uhf_worker_start(
+        uhf_app->worker, UHFWorkerStateWriteSingle, uhf_write_tag_worker_callback, uhf_app);
+
+    uhf_blink_start(uhf_app);
+}
+
+bool uhf_scene_write_tag_on_event(void* ctx, SceneManagerEvent event) {
+    UHFApp* uhf_app = ctx;
+    bool consumed = false;
+    if(event.event == UHFCustomEventWorkerExit) {
+        scene_manager_next_scene(uhf_app->scene_manager, UHFSceneReadTagSuccess);
+        consumed = true;
+    }
+    return consumed;
+}
+
+void uhf_scene_write_tag_on_exit(void* ctx) {
+    UHFApp* uhf_app = ctx;
+    // Stop worker
+    uhf_worker_stop(uhf_app->worker);
+    // Clear view
+    popup_reset(uhf_app->popup);
+
+    uhf_blink_stop(uhf_app);
+}

scenes/uhf_scene_write_tag_success.c

@@ -0,0 +1,95 @@
+#include "../uhf_app_i.h"
+#include <dolphin/dolphin.h>
+
+void uhf_write_tag_success_worker_callback(UHFWorkerEvent event, void* ctx) {
+    UNUSED(event);
+    UNUSED(ctx);
+}
+
+void uhf_scene_read_card_success_widget_callback(GuiButtonType result, InputType type, void* ctx) {
+    furi_assert(ctx);
+    UHFApp* uhf_app = ctx;
+
+    if(type == InputTypeShort) {
+        view_dispatcher_send_custom_event(uhf_app->view_dispatcher, result);
+    }
+}
+
+void uhf_scene_write_tag_success_on_enter(void* ctx) {
+    UHFApp* uhf_app = ctx;
+    UHFTag* uhf_tag = uhf_app->worker->uhf_tag;
+
+    dolphin_deed(DolphinDeedNfcWriteSuccess);
+
+    // Send notification
+    notification_message(uhf_app->notifications, &sequence_success);
+
+    // widget_add_string_element(
+    //     uhf_app->widget, 32, 5, AlignLeft, AlignCenter, FontPrimary, "Write Success");
+
+    // widget_add_string_element(uhf_app->widget, 3, 18, AlignLeft, AlignCenter, FontPrimary, "PC :");
+
+    // widget_add_string_element(
+    //     uhf_app->widget, 66, 18, AlignLeft, AlignCenter, FontPrimary, "CRC :");
+
+    // widget_add_string_element(
+    //     uhf_app->widget, 3, 32, AlignLeft, AlignCenter, FontPrimary, "EPC :");
+
+    // char* pc = convertToHexString(uhf_tag->pc, 2);
+    // widget_add_string_element(uhf_app->widget, 26, 19, AlignLeft, AlignCenter, FontKeyboard, pc);
+    // char* crc = convertToHexString(uhf_tag->crc, 2);
+    // widget_add_string_element(uhf_app->widget, 96, 19, AlignLeft, AlignCenter, FontKeyboard, crc);
+    // char* epc = convertToHexString(uhf_tag->epc + 2, uhf_tag->epc_length - 2);
+    // widget_add_string_multiline_element(
+    //     uhf_app->widget, 34, 29, AlignLeft, AlignTop, FontKeyboard, epc);
+
+    widget_add_button_element(
+        uhf_app->widget,
+        GuiButtonTypeRight,
+        "More",
+        uhf_scene_read_card_success_widget_callback,
+        uhf_app);
+    widget_add_button_element(
+        uhf_app->widget,
+        GuiButtonTypeLeft,
+        "Exit",
+        uhf_scene_read_card_success_widget_callback,
+        uhf_app);
+    view_dispatcher_switch_to_view(uhf_app->view_dispatcher, UHFViewWidget);
+    // free(pc);
+    // free(crc);
+    // free(epc);
+}
+
+bool uhf_scene_write_tag_success_on_event(void* ctx, SceneManagerEvent event) {
+    UHFApp* uhf_app = ctx;
+    bool consumed = false;
+    if(event.event == SceneManagerEventTypeBack) {
+        uhf_app->worker->state = UHFWorkerStateStop;
+    }
+    if(event.type == SceneManagerEventTypeCustom) {
+        // if 'exit' is pressed go back to home screen
+        if(event.event == GuiButtonTypeLeft) {
+            consumed = scene_manager_search_and_switch_to_previous_scene(
+                uhf_app->scene_manager, UHFSceneStart);
+        } else if(event.event == GuiButtonTypeRight) {
+            scene_manager_next_scene(uhf_app->scene_manager, UHFSceneTagMenu);
+            consumed = true;
+        } else if(event.event == GuiButtonTypeCenter) {
+            // consumed = scene_manager_search_and_switch_to_another_scene(
+            //     picopass->scene_manager, PicopassSceneStart);
+        }
+    }
+    return consumed;
+}
+
+void uhf_scene_write_tag_success_on_exit(void* ctx) {
+    UHFApp* uhf_app = ctx;
+
+    // // Stop worker
+    uhf_worker_stop(uhf_app->worker);
+    // Clear view
+    popup_reset(uhf_app->popup);
+    // clear widget
+    widget_reset(uhf_app->widget);
+}

uhf_worker.c

@@ -98,15 +98,7 @@ static bool read_bank(UHFData* read_bank_cmd, UHFData* response_bank, UHFBank ba
     return response_bank->data[2] == read_bank_cmd->data[2];
 }
 
-UHFWorkerEvent read_single_card(UHFWorker* uhf_worker) {
-    // debug
-    // FuriString* temp_str;
-    // temp_str = furi_string_alloc();
-    // e-debug
-    UHFResponseData* uhf_response_data = uhf_worker->response_data;
-    uhf_response_data_reset(uhf_response_data);
-    UHFData* raw_read_data = uhf_response_data_get_uhf_data(uhf_response_data, 0);
-    furi_hal_uart_set_br(FuriHalUartIdUSART1, DEFAULT_BAUD_RATE);
+UHFWorkerEvent send_polling_command(UHFWorker* uhf_worker, UHFData* raw_read_data) {
     furi_hal_uart_set_irq_cb(FuriHalUartIdUSART1, module_rx_callback, raw_read_data);
     uhf_data_reset(raw_read_data);
     // read epc bank
@@ -124,6 +116,20 @@ UHFWorkerEvent read_single_card(UHFWorker* uhf_worker) {
                 break; // read success
         }
     }
+    return UHFWorkerEventSuccess;
+}
+
+UHFWorkerEvent read_single_card(UHFWorker* uhf_worker) {
+    // debug
+    // FuriString* temp_str;
+    // temp_str = furi_string_alloc();
+    // e-debug
+    UHFResponseData* uhf_response_data = uhf_worker->response_data;
+    uhf_response_data_reset(uhf_response_data);
+    UHFData* raw_read_data = uhf_response_data_get_uhf_data(uhf_response_data, 0);
+    furi_hal_uart_set_br(FuriHalUartIdUSART1, DEFAULT_BAUD_RATE);
+
+    send_polling_command(uhf_worker, raw_read_data);
 
     // todo : rfu ?
     UHFTag* uhf_tag = uhf_worker->uhf_tag;
@@ -201,15 +207,20 @@ UHFWorkerEvent read_single_card(UHFWorker* uhf_worker) {
     return UHFWorkerEventSuccess;
 }
 
+UHFWorkerEvent write_single_card(UHFWorker* worker) {
+}
+
 int32_t uhf_worker_task(void* ctx) {
     UHFWorker* uhf_worker = ctx;
     if(uhf_worker->state == UHFWorkerStateVerify) {
         UHFWorkerEvent event = verify_module_connected(uhf_worker);
         uhf_worker->callback(event, uhf_worker->ctx);
-    }
-    if(uhf_worker->state == UHFWorkerStateDetectSingle) {
+    } else if(uhf_worker->state == UHFWorkerStateDetectSingle) {
         UHFWorkerEvent event = read_single_card(uhf_worker);
         uhf_worker->callback(event, uhf_worker->ctx);
+    } else if(uhf_worker->state == UHFWorkerStateWriteSingle) {
+        UHFWorkerEvent event = write_single_card(uhf_worker);
+        uhf_worker->callback(event, uhf_worker->ctx);
     }
     return 0;
 }