bug fixes and more refractoring

uhf_app.c

@@ -61,7 +61,8 @@ UHFApp* uhf_alloc() {
     uhf_app->uhf_device = uhf_device_alloc();
 
     UHFTagWrapper* uhf_tag_wrapper = uhf_tag_wrapper_alloc();
-    // point tag object to worker
+
+    // // point tag object to worker
     uhf_app->worker->uhf_tag_wrapper = uhf_tag_wrapper;
     uhf_app->uhf_device->uhf_tag_wrapper = uhf_tag_wrapper;
 
@@ -119,12 +120,15 @@ void uhf_free(UHFApp* uhf_app) {
     view_dispatcher_remove_view(uhf_app->view_dispatcher, UHFViewWidget);
     widget_free(uhf_app->widget);
 
+    // Tag
+    uhf_tag_wrapper_free(uhf_app->worker->uhf_tag_wrapper);
+
     // Worker
     uhf_worker_stop(uhf_app->worker);
     uhf_worker_free(uhf_app->worker);
 
-    // Tag
-    uhf_tag_wrapper_free(uhf_app->worker->uhf_tag_wrapper);
+    // Device
+    uhf_device_free(uhf_app->uhf_device);
 
     // View Dispatcher
     view_dispatcher_free(uhf_app->view_dispatcher);
@@ -136,9 +140,6 @@ void uhf_free(UHFApp* uhf_app) {
     furi_record_close(RECORD_GUI);
     uhf_app->gui = NULL;
 
-    // UHFDevice
-    uhf_device_free(uhf_app->uhf_device);
-
     // Notifications
     furi_record_close(RECORD_NOTIFICATION);
     uhf_app->notifications = NULL;

uhf_buffer.c

@@ -4,14 +4,11 @@
 
 Buffer* buffer_alloc(size_t initial_capacity) {
     Buffer* buf = (Buffer*)malloc(sizeof(Buffer));
-    if(!buf) return NULL;
-
-    buf->data = (uint8_t*)malloc(initial_capacity);
+    buf->data = (uint8_t*)malloc(sizeof(uint8_t) * initial_capacity);
     if(!buf->data) {
         free(buf);
         return NULL;
     }
-
     buf->size = 0;
     buf->capacity = initial_capacity;
     return buf;
@@ -21,7 +18,7 @@ bool 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, new_capacity);
+        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;

uhf_device.c

@@ -20,7 +20,6 @@ UHFDevice* uhf_device_alloc() {
 
 void uhf_device_set_name(UHFDevice* dev, const char* name) {
     furi_assert(dev);
-
     strlcpy(dev->dev_name, name, UHF_DEV_NAME_MAX_LEN);
 }
 

uhf_module.c

@@ -3,10 +3,10 @@
 
 #define DELAY_MS 50
 
-static void rx_callback(UartIrqEvent event, uint8_t data, void* ctx) {
+void rx_callback(UartIrqEvent event, uint8_t data, void* ctx) {
     UNUSED(event);
     Buffer* buf = ctx;
-    if(data == FRAME_END) buffer_close(buf);
+    if(data == (u_int8_t)FRAME_END) buffer_close(buf);
     buffer_append_single(buf, data);
 }
 
@@ -28,6 +28,8 @@ M100Module* m100_module_alloc() {
     M100Module* module = (M100Module*)malloc(sizeof(M100Module));
     module->info = m100_module_info_alloc();
     module->buf = buffer_alloc(128);
+    furi_hal_uart_set_br(FuriHalUartIdUSART1, DEFAULT_BAUDRATE);
+    module->baudrate = (uint16_t)(DEFAULT_BAUDRATE);
     return module;
 }
 
@@ -66,7 +68,7 @@ uint16_t crc16_genibus(const uint8_t* data, size_t length) {
 }
 
 char* m100_get_hardware_version(M100Module* module) {
-    if(!(((void*)module->info->sw_version) == NULL)) 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, (uint8_t*)&CMD_HW_VERSION.cmd[0], CMD_HW_VERSION.length);
@@ -75,14 +77,18 @@ char* m100_get_hardware_version(M100Module* module) {
     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);
+    FuriString* temp_str = furi_string_alloc();
+    for(int i = 0; i < payload_len; i++) {
+        furi_string_cat_printf(temp_str, "%c", data[6 + i]);
+    }
+    char* hw_version = (char*)malloc(sizeof(char) * payload_len);
+    memcpy(hw_version, furi_string_get_cstr(temp_str), payload_len);
     module->info->hw_version = hw_version;
-    free(hw_version);
+    furi_string_free(temp_str);
     return module->info->hw_version;
 }
 char* m100_get_software_version(M100Module* module) {
-    if(!(((void*)module->info->hw_version) == NULL)) return module->info->hw_version;
+    if(module->info->sw_version != NULL) return module->info->sw_version;
     buffer_reset(module->buf);
     furi_hal_uart_set_irq_cb(FuriHalUartIdUSART1, rx_callback, module->buf);
     furi_hal_uart_tx(FuriHalUartIdUSART1, (uint8_t*)&CMD_SW_VERSION.cmd[0], CMD_SW_VERSION.length);
@@ -91,14 +97,18 @@ char* m100_get_software_version(M100Module* module) {
     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);
+    FuriString* temp_str = furi_string_alloc();
+    for(int i = 0; i < payload_len; i++) {
+        furi_string_cat_printf(temp_str, "%c", data[6 + i]);
+    }
+    char* sw_version = (char*)malloc(sizeof(char) * payload_len);
+    memcpy(sw_version, furi_string_get_cstr(temp_str), payload_len);
     module->info->sw_version = sw_version;
-    free(sw_version);
+    furi_string_free(temp_str);
     return module->info->sw_version;
 }
 char* m100_get_manufacturers(M100Module* module) {
-    if(!(((void*)module->info->manufacturer) == NULL)) 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(
@@ -108,34 +118,47 @@ char* m100_get_manufacturers(M100Module* module) {
     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);
+    FuriString* temp_str = furi_string_alloc();
+    for(int i = 0; i < payload_len; i++) {
+        furi_string_cat_printf(temp_str, "%c", data[6 + i]);
+    }
+    char* manufacturer = (char*)malloc(sizeof(char) * payload_len);
+    memcpy(manufacturer, furi_string_get_cstr(temp_str), payload_len);
     module->info->manufacturer = manufacturer;
-    free(manufacturer);
+    furi_string_free(temp_str);
     return module->info->manufacturer;
 }
 
 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_set_irq_cb(FuriHalUartIdUSART1, rx_callback, module->buf);
     furi_hal_uart_tx(
         FuriHalUartIdUSART1, (uint8_t*)&CMD_SINGLE_POLLING.cmd[0], CMD_SINGLE_POLLING.length);
     furi_delay_ms(DELAY_MS);
+    for(size_t i = 0; i < buffer_get_size(module->buf); i++) {
+        FURI_LOG_E("M100", "data[%d]=%02X", i, buffer_get_data(module->buf)[i]);
+    }
+    FURI_LOG_E("M100", "END");
     uint8_t* data = buffer_get_data(module->buf);
     size_t length = buffer_get_size(module->buf);
-    if(length == 7 && data[2] == 0xFF) return NULL;
+    if(length <= 7 && data[2] == 0xFF) return NULL;
     uint16_t pc = data[6];
     uint16_t crc = 0;
+    // mask out epc length from protocol control
     size_t epc_len = pc;
     epc_len <<= 1;
     epc_len += (data[7] & 0x80) > 0;
     epc_len *= 2;
+    // get protocol control
     pc <<= 8;
     pc += data[7];
     crc = data[8 + epc_len + 1];
+    // get cyclic redundency check
     crc <<= 8;
     crc += data[8 + epc_len + 2];
+    // validate checksum
     if(checksum(data + 1, length - 3) != data[length - 2]) return NULL;
+    // validate crc
     if(crc16_genibus(data + 6, epc_len + 2) != crc) return NULL;
     UHFTag* uhf_tag = uhf_tag_alloc();
     uhf_tag_set_epc_pc(uhf_tag, pc);
@@ -229,7 +252,7 @@ bool m100_set_working_area(M100Module* module, WorkingArea area) {
     uint8_t cmd[length];
     memcpy(cmd, CMD_SET_WORK_AREA.cmd, length);
     cmd[5] = area;
-    Buffer* buf = buffer_alloc(9);
+    Buffer* buf = buffer_alloc(12);
     furi_hal_uart_set_irq_cb(FuriHalUartIdUSART1, rx_callback, buf);
     furi_hal_uart_tx(FuriHalUartIdUSART1, cmd, length);
     buffer_free(buf);
@@ -250,4 +273,4 @@ bool m100_set_freq_hopping(M100Module* module, bool hopping) {
     UNUSED(module);
     UNUSED(hopping);
     return true;
-}
+}

uhf_module.h

@@ -8,6 +8,7 @@
 #include <furi_hal.h>
 
 #define FRAME_END 0x7E
+#define DEFAULT_BAUDRATE 115200
 
 typedef struct{
     char* hw_version;

uhf_tag.c

@@ -13,7 +13,7 @@ void uhf_tag_wrapper_set_tag(UHFTagWrapper* uhf_tag_wrapper, UHFTag* 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);
+    uhf_tag_free(uhf_tag_wrapper->uhf_tag);
     free(uhf_tag_wrapper);
 }
 
@@ -35,6 +35,7 @@ void uhf_tag_reset(UHFTag* uhf_tag) {
 }
 
 void uhf_tag_free(UHFTag* uhf_tag) {
+    if(uhf_tag == NULL) return;
     free(uhf_tag->reserved);
     free(uhf_tag->epc);
     free(uhf_tag->tid);

uhf_worker.c

@@ -3,15 +3,11 @@
 
 // yrm100 module commands
 UHFWorkerEvent verify_module_connected(UHFWorker* uhf_worker) {
-    // FuriString* ts = furi_string_alloc();
     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;
-    FURI_LOG_E("TAG", "hw=%s", hw_version);
-    FURI_LOG_E("TAG", "sw=%s", sw_version);
-    FURI_LOG_E("TAG", "mf=%s", manufacturer);
     return UHFWorkerEventSuccess;
 }
 
@@ -65,11 +61,12 @@ UHFTag* send_polling_command(UHFWorker* uhf_worker) {
     UHFTag* uhf_tag;
     while(true) {
         uhf_tag = m100_send_single_poll(uhf_worker->module);
-        furi_delay_ms(100);
+        furi_delay_ms(150);
         if(uhf_worker->state == UHFWorkerStateStop) {
             return NULL;
         }
         if(uhf_tag != NULL) break;
+        FURI_LOG_E("TAG", "NULL");
     }
     return uhf_tag;
 }