still refractoring

uhf_app.c

@@ -60,10 +60,10 @@ UHFApp* uhf_alloc() {
     // device
     uhf_app->uhf_device = uhf_device_alloc();
 
-    UHFTag* uhf_tag = uhf_tag_alloc();
+    UHFTagWrapper* uhf_tag_wrapper = uhf_tag_wrapper_alloc();
     // point tag object to worker
-    uhf_app->worker->uhf_tag = uhf_tag;
-    uhf_app->uhf_device->uhf_tag = uhf_tag;
+    uhf_app->worker->uhf_tag = uhf_tag_wrapper;
+    uhf_app->uhf_device->uhf_tag = uhf_tag_wrapper;
 
     // Open Notification record
     uhf_app->notifications = furi_record_open(RECORD_NOTIFICATION);
@@ -124,7 +124,7 @@ void uhf_free(UHFApp* uhf_app) {
     uhf_worker_free(uhf_app->worker);
 
     // Tag
-    uhf_tag_free(uhf_app->worker->uhf_tag);
+    uhf_tag_wrapper_free(uhf_app->worker->uhf_tag_wrapper);
 
     // View Dispatcher
     view_dispatcher_free(uhf_app->view_dispatcher);

uhf_device.h

@@ -5,7 +5,7 @@
 #include <storage/storage.h>
 #include <dialogs/dialogs.h>
 #include <mbedtls/des.h>
-#include "uhf_data.h"
+#include "uhf_tag.h"
 
 // #include "rfal_picopass.h"
 
@@ -28,15 +28,13 @@
 #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 {
     Storage* storage;
     DialogsApp* dialogs;
-    // UHFResponseData* dev_data;
-    UHFTag* uhf_tag;
+    UHFTagWrapper* uhf_tag_wrapper;
     char dev_name[UHF_DEV_NAME_MAX_LEN + 1];
     FuriString* load_path;
     UHFLoadingCallback loading_cb;

uhf_module.c

@@ -1,8 +1,7 @@
 #include "uhf_module.h"
 #include "uhf_module_cmd.h"
-#include "uhf_buffer.h"
-#include "uhf_tag.h"
-#include <furi_hal.h>
+
+#define DELAY_MS 50
 
 static void rx_callback(UartIrqEvent event, uint8_t data, void* ctx) {
     UNUSED(event);
@@ -16,6 +15,9 @@ static void rx_callback(UartIrqEvent event, uint8_t data, void* ctx) {
 
 M100ModuleInfo* m100_module_info_alloc() {
     M100ModuleInfo* module_info = (M100ModuleInfo*)malloc(sizeof(M100ModuleInfo));
+    module_info->hw_version = NULL;
+    module_info->sw_version = NULL;
+    module_info->manufacturer = NULL;
     return module_info;
 }
 
@@ -37,7 +39,7 @@ void m100_module_free(M100Module* module) {
     free(module);
 }
 
-uint8_t checksum(uint8_t* data, size_t length) {
+uint8_t checksum(const uint8_t* data, size_t length) {
     // CheckSum8 Modulo 256
     // Sum of Bytes % 256
     uint8_t sum_val = 0x00;
@@ -66,19 +68,56 @@ uint16_t crc16_genibus(const uint8_t* data, size_t length) {
 }
 
 char* m100_get_hardware_version(M100Module* module) {
-    return module->info->hw_version;
+    if(!module->info->hw_version == NULL) return module->info->hw_version;
+    buffer_reset(module->buf);
+    furi_hal_uart_set_irq_cb(FuriHalUartIdUSART1, rx_callback, module->buf);
+    furi_hal_uart_tx(FuriHalUartIdUSART1, CMD_HW_VERSION.cmd, CMD_HW_VERSION.length);
+    furi_delay_ms(DELAY_MS);
+    if(!buffer_get_size(module->buf)) return NULL;
+    uint8_t* data = buffer_get_data(module->buf);
+    uint16_t payload_len = data[3];
+    payload_len = (payload_len << 8) + data[4];
+    char hw_version[payload_len];
+    memcpy(hw_version, data + 6, (size_t)payload_len);
+    module->info->hw_version = hw_version;
+    return hw_version;
 }
 char* m100_get_software_version(M100Module* module) {
-    return module->info->sw_version;
+    if(!module->info->sw_version == NULL) return module->info->hw_version;
+    buffer_reset(module->buf);
+    furi_hal_uart_set_irq_cb(FuriHalUartIdUSART1, rx_callback, module->buf);
+    furi_hal_uart_tx(FuriHalUartIdUSART1, CMD_SW_VERSION.cmd, CMD_SW_VERSION.length);
+    furi_delay_ms(DELAY_MS);
+    if(!buffer_get_size(module->buf)) return NULL;
+    uint8_t* data = buffer_get_data(module->buf);
+    uint16_t payload_len = data[3];
+    payload_len = (payload_len << 8) + data[4];
+    char sw_version[payload_len];
+    memcpy(sw_version, data + 6, (size_t)payload_len);
+    module->info->sw_version = sw_version;
+    return sw_version;
 }
 char* m100_get_manufacturers(M100Module* module) {
-    return module->info->manufacturer;
+    if(!module->info->manufacturer == NULL) return module->info->manufacturer;
+    buffer_reset(module->buf);
+    furi_hal_uart_set_irq_cb(FuriHalUartIdUSART1, rx_callback, module->buf);
+    furi_hal_uart_tx(FuriHalUartIdUSART1, CMD_MANUFACTURERS.cmd, CMD_MANUFACTURERS.length);
+    furi_delay_ms(DELAY_MS);
+    if(!buffer_get_size(module->buf)) return NULL;
+    uint8_t* data = buffer_get_data(module->buf);
+    uint16_t payload_len = data[3];
+    payload_len = (payload_len << 8) + data[4];
+    char manufacturer[payload_len];
+    memcpy(manufacturer, data + 6, (size_t)payload_len);
+    module->info->manufacturer = manufacturer;
+    return manufacturer;
 }
 
-UHFTag* m100_read_single(M100Module* module) {
+UHFTag* m100_send_single_poll(M100Module* module) {
     buffer_reset(module->buf);
     furi_hal_uart_set_irq_cb(FuriHalUartIdLPUART1, rx_callback, module->buf);
     furi_hal_uart_tx(FuriHalUartIdUSART1, CMD_SINGLE_POLLING.cmd, CMD_SINGLE_POLLING.length);
+    furi_delay_ms(DELAY_MS);
     uint8_t* data = buffer_get_data(module->buf);
     size_t length = buffer_get_size(module->buf);
     if(length == 7 && data[2] == 0xFF) return NULL;
@@ -102,6 +141,44 @@ UHFTag* m100_read_single(M100Module* module) {
     return uhf_tag;
 }
 
+bool m100_set_select(M100Module* module, UHFTag* uhf_tag) {
+    buffer_reset(module->buf);
+    // Set select
+    uint8_t cmd[MAX_BUFFER_SIZE];
+    size_t cmd_length = CMD_SET_SELECT_PARAMETER.length;
+    size_t mask_length_bytes = uhf_tag->epc->size;
+    size_t mask_length_bits = mask_length_bytes * 8;
+    size_t payload_len = 7 + mask_length_bytes;
+    memcpy(cmd, CMD_SET_SELECT_PARAMETER.cmd, cmd_length);
+    // set payload length
+    // payload len = sel param len + ptr len + mask len + epc len
+    cmd[3] = (payload_len >> 8) & 0xFF;
+    cmd[4] = payload_len & 0xFF;
+    // set select param
+    cmd[5] = 0x01; // 0x00=rfu, 0x01=epc, 0x10=tid, 0x11=user
+    // set ptr
+    cmd[9] = 0x20; // epc data begins after 0x20
+    // set mask length
+    cmd[10] = mask_length_bits;
+    // truncate
+    cmd[11] = false;
+    // set mask
+    memcpy(cmd[12], uhf_tag->epc->data, mask_length_bytes);
+    // set checksum
+    cmd[12 + mask_length_bytes + 1] = checksum(cmd + 1, 11 + mask_length_bytes);
+    // end frame
+    cmd[12 + mask_length_bytes + 2] = FRAME_END;
+    furi_hal_uart_set_irq_cb(FuriHalUartIdLPUART1, rx_callback, module->buf);
+    furi_hal_uart_tx(FuriHalUartIdUSART1, cmd, 12 + mask_length_bytes + 3);
+    furi_delay_ms(DELAY_MS);
+
+    uint8_t* data = buffer_get_data(module->buf);
+    if(checksum(data + 1, 5) != data[6]) return false; // error in rx
+    if(data[5] != 0x00) return false; // error if not 0
+
+    return true;
+}
+
 void m100_set_baudrate(M100Module* module, uint16_t baudrate) {
     size_t length = CMD_SET_COMMUNICATION_BAUD_RATE.length;
     uint8_t cmd[length];

uhf_module.h

@@ -4,6 +4,8 @@
 #include <stdbool.h>
 #include <stddef.h>
 #include "uhf_buffer.h"
+#include "uhf_tag.h"
+#include <furi_hal.h>
 
 #define FRAME_END 0x7E
 
@@ -51,8 +53,14 @@ uint8_t checksum(const uint8_t* data, size_t length);
 char* m100_get_hardware_version(M100Module* module);
 char* m100_get_software_version(M100Module* module);
 char* m100_get_manufacturers(M100Module* module);
+
+// set attrs
 void m100_set_baudrate(M100Module* module, uint16_t baudrate);
 bool m100_set_working_area(M100Module* module, WorkingArea area);
 bool m100_set_working_channel(M100Module* module, WorkingChannel channel);
 bool m100_set_transmitting_power(M100Module* module, uint16_t power);
-bool m100_set_freq_hopping(M100Module* module, bool hopping);
+bool m100_set_freq_hopping(M100Module* module, bool hopping);
+
+// gen2 cmds
+UHFTag* m100_send_single_poll(M100Module* module);
+bool m100_set_select(M100Module* module, UHFTag* uhf_tag);

uhf_tag.c

@@ -0,0 +1,34 @@
+#include "uhf_tag.h"
+
+UHFTag* uhf_tag_alloc() {
+    UHFTag* uhf_tag = (UHFTag*)malloc(sizeof(UHFTag));
+    uhf_tag->reserved = (ReservedMemoryBank*)malloc(sizeof(ReservedMemoryBank));
+    uhf_tag->epc = (EPCMemoryBank*)malloc(sizeof(EPCMemoryBank));
+    uhf_tag->tid = (TIDMemoryBank*)malloc(sizeof(TIDMemoryBank));
+    uhf_tag->user = (UserMemoryBank*)malloc(sizeof(UserMemoryBank));
+    return uhf_tag;
+}
+
+void uhf_tag_free(UHFTag* uhf_tag) {
+    free(uhf_tag->reserved);
+    free(uhf_tag->epc);
+    free(uhf_tag->tid);
+    free(uhf_tag->user);
+    free(uhf_tag);
+}
+
+UHFTagWrapper* uhf_tag_wrapper_alloc(){
+    UHFTagWrapper* uhf_tag_wrapper = (UHFTagWrapper*)malloc(sizeof(UHFTagWrapper));
+    uhf_tag_wrapper->uhf_tag = NULL;
+    return uhf_tag_wrapper;
+}
+
+void uhf_tag_wrapper_set_tag(UHFTagWrapper* uhf_tag_wrapper, UHFTag* uhf_tag){
+    uhf_tag_wrapper->uhf_tag = uhf_tag;
+}
+
+void uhf_tag_wrapper_free(UHFTagWrapper* uhf_tag_wrapper){
+    if(uhf_tag_wrapper->uhf_tag != NULL)
+        uhf_tag_free(uhf_tag_wrapper->uhf_tag);
+    free(uhf_tag_wrapper);
+}

uhf_tag.h

@@ -38,6 +38,14 @@ typedef struct {
     UserMemoryBank* user;
 } UHFTag;
 
+typedef struct UHFTagWrapper{
+    UHFTag* uhf_tag;
+}UHFTagWrapper;
+
+UHFTagWrapper* uhf_tag_wrapper_alloc();
+void uhf_tag_wrapper_set_tag(UHFTagWrapper* uhf_tag_wrapper, UHFTag* uhf_tag);
+void uhf_tag_wrapper_free(UHFTagWrapper* uhf_tag_wrapper);
+
 UHFTag* uhf_tag_alloc();
 void uhf_tag_free(UHFTag* uhf_tag);
 
@@ -57,3 +65,6 @@ uint8_t* uhf_tag_get_tid(UHFTag* uhf_tag);
 size_t uhf_tag_get_tid_size(UHFTag* uhf_tag);
 uint8_t* uhf_tag_get_user(UHFTag* uhf_tag);
 size_t uhf_tag_get_user_size(UHFTag* uhf_tag);
+
+// debug
+char* uhf_tag_get_cstr(UHFTag* uhf_tag);

uhf_worker.c

@@ -1,46 +1,13 @@
 #include "uhf_worker.h"
-#include "uhf_cmd.h"
-
-#define CB_DELAY 50
-
-// uart callback functions
-void module_rx_callback(UartIrqEvent event, uint8_t data, void* ctx) {
-    UNUSED(event);
-    UHFData* uhf_data = ctx;
-    uhf_data_append(uhf_data, data);
-}
+#include "uhf_tag.h"
 
 // yrm100 module commands
 UHFWorkerEvent verify_module_connected(UHFWorker* uhf_worker) {
-    UHFResponseData* uhf_response_data = uhf_worker->response_data;
-    uhf_response_data_reset(uhf_response_data);
-    // FURI_LOG_E("log", "freeing done");
-    UHFData* hardware_version = uhf_response_data->head;
-    UHFData* software_version = uhf_response_data_add_new_uhf_data(uhf_response_data);
-    UHFData* manufacturer = uhf_response_data_add_new_uhf_data(uhf_response_data);
-    // FURI_LOG_E("log", "alloc done");
-    furi_hal_uart_set_br(FuriHalUartIdUSART1, DEFAULT_BAUD_RATE);
-    // read hardware version
-    furi_hal_uart_set_irq_cb(FuriHalUartIdUSART1, module_rx_callback, hardware_version);
-    furi_hal_uart_tx(FuriHalUartIdUSART1, CMD_HARDWARE_VERSION.cmd, CMD_HARDWARE_VERSION.length);
-    furi_delay_ms(CB_DELAY);
-    // read software version
-    furi_hal_uart_set_irq_cb(FuriHalUartIdUSART1, module_rx_callback, software_version);
-    furi_hal_uart_tx(FuriHalUartIdUSART1, CMD_SOFTWARE_VERSION.cmd, CMD_SOFTWARE_VERSION.length);
-    furi_delay_ms(CB_DELAY);
-    // read manufacturer
-    furi_hal_uart_set_irq_cb(FuriHalUartIdUSART1, module_rx_callback, manufacturer);
-    furi_hal_uart_tx(FuriHalUartIdUSART1, CMD_MANUFACTURERS.cmd, CMD_MANUFACTURERS.length);
-    furi_delay_ms(CB_DELAY);
-    // verify that we received all data
-    if(!hardware_version->end || !software_version->end || !manufacturer->end) {
-        return UHFWorkerEventFail;
-    }
-    // verify all data was received correctly
-    if(!uhf_data_verfiy_checksum(hardware_version) ||
-       !uhf_data_verfiy_checksum(software_version) || !uhf_data_verfiy_checksum(manufacturer))
-        return UHFWorkerEventFail;
-
+    char* hw_version = m100_get_hardware_version(uhf_worker->module);
+    char* sw_version = m100_get_software_version(uhf_worker->module);
+    char* manufacturer = m100_get_manufacturers(uhf_worker->module);
+    // verify all data exists
+    if(hw_version == NULL || sw_version == NULL || manufacturer == NULL) return UHFWorkerEventFail;
     return UHFWorkerEventSuccess;
 }
 
@@ -127,38 +94,24 @@ bool write_bank(UHFData* write_bank_cmd, UHFBank bank, uint8_t* bank_data, size_
     return success;
 }
 
-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);
+UHFTag* send_polling_command(UHFWorker* uhf_worker) {
     // read epc bank
+    UHFTag* uhf_tag;
     while(true) {
-        furi_hal_uart_tx(FuriHalUartIdUSART1, CMD_SINGLE_POLLING.cmd, CMD_SINGLE_POLLING.length);
+        uhf_tag = m100_send_single_poll(uhf_worker->module);
         furi_delay_ms(100);
         if(uhf_worker->state == UHFWorkerStateStop) {
-            return UHFWorkerEventAborted;
-        }
-        if(raw_read_data->end) {
-            if(raw_read_data->data[1] == 0x01 && raw_read_data->data[5] == 0x15) {
-                uhf_data_reset(raw_read_data);
-                continue;
-            } else if(raw_read_data->data[1] == 0x02)
-                break; // read success
+            return NULL;
         }
+        if(uhf_tag != NULL) break;
     }
-    return UHFWorkerEventSuccess;
+
+    return uhf_tag;
 }
 
 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);
+    UHFTag*
 
     // todo : rfu ?
     UHFTag* uhf_tag = uhf_worker->uhf_tag;
@@ -286,7 +239,7 @@ int32_t uhf_worker_task(void* ctx) {
 UHFWorker* uhf_worker_alloc() {
     UHFWorker* uhf_worker = (UHFWorker*)malloc(sizeof(UHFWorker));
     uhf_worker->thread = furi_thread_alloc_ex("UHFWorker", 8 * 1024, uhf_worker_task, uhf_worker);
-    uhf_worker->response_data = uhf_response_data_alloc();
+    uhf_worker->module = m100_module_alloc();
     uhf_worker->callback = NULL;
     uhf_worker->ctx = NULL;
     return uhf_worker;
@@ -320,6 +273,6 @@ void uhf_worker_stop(UHFWorker* uhf_worker) {
 void uhf_worker_free(UHFWorker* uhf_worker) {
     furi_assert(uhf_worker);
     furi_thread_free(uhf_worker->thread);
-    uhf_response_data_free(uhf_worker->response_data);
+    m100_module_free(uhf_worker->module);
     free(uhf_worker);
 }

uhf_worker.h

@@ -2,7 +2,7 @@
 
 #include <furi.h>
 #include <furi_hal.h>
-#include "uhf_data.h"
+#include "uhf_module.h"
 
 typedef enum {
     // Init states
@@ -30,10 +30,10 @@ typedef void (*UHFWorkerCallback)(UHFWorkerEvent event, void* ctx);
 
 typedef struct UHFWorker {
     FuriThread* thread;
-    UHFResponseData* response_data;
-    UHFTag* uhf_tag;
+    M100Module* module;
     UHFWorkerCallback callback;
     UHFWorkerState state;
+    UHFTagWrapper* uhf_tag_wrapper;
     void* ctx;
 } UHFWorker;