changed rx settings to respond to corrupt or failed/data + 2 more module settings

scenes/uhf_scene_settings.c

@@ -4,6 +4,9 @@
 void uhf_settings_set_module_baudrate(VariableItem* item) {
     M100Module* uhf_module = variable_item_get_context(item);
     uint8_t index = variable_item_get_current_value_index(item);
+    if(index >= BAUD_RATES_COUNT) {
+        return;
+    }
     uint32_t baudrate = BAUD_RATES[index];
     m100_set_baudrate(uhf_module, baudrate);
     char text_buf[10];
@@ -12,13 +15,32 @@ void uhf_settings_set_module_baudrate(VariableItem* item) {
 }
 
 void uhf_settings_set_module_powerdb(VariableItem* item) {
-    UNUSED(item);
+    M100Module* uhf_module = variable_item_get_context(item);
+    uint8_t index = variable_item_get_current_value_index(item);
+    if(index >= POWER_DBM_COUNT) {
+        return;
+    }
+    uint16_t power = POWER_DBM[index];
+    m100_set_transmitting_power(uhf_module, power);
+    char text_buf[10];
+    snprintf(text_buf, sizeof(text_buf), "%ddBm", uhf_module->transmitting_power);
+    variable_item_set_current_value_text(item, text_buf);
+}
+
+void uhf_settings_set_module_working_region(VariableItem* item) {
+    M100Module* uhf_module = variable_item_get_context(item);
+    uint8_t index = variable_item_get_current_value_index(item);
+    if(index >= WORKING_REGIONS_COUNT) {
+        return;
+    }
+    WorkingRegion region = WORKING_REGIONS[index];
+    m100_set_working_region(uhf_module, region);
+    variable_item_set_current_value_text(item, WORKING_REGIONS_STR[index]);
 }
 
 uint8_t uhf_settings_get_module_baudrate_index(M100Module* module) {
-    uint32_t baudrate = module->baudrate;
-    for(uint8_t i = 0; i < sizeof(BAUD_RATES); i++) {
-        if(BAUD_RATES[i] == baudrate) {
+    for(uint8_t i = 0; i < BAUD_RATES_COUNT; i++) {
+        if(BAUD_RATES[i] == module->baudrate) {
             return i;
         }
     }
@@ -26,9 +48,17 @@ uint8_t uhf_settings_get_module_baudrate_index(M100Module* module) {
 }
 
 uint8_t uhf_settings_get_module_power_index(M100Module* module) {
-    uint16_t power = module->transmitting_power;
-    for(uint8_t i = 0; i < sizeof(POWER_DBM); i++) {
-        if(POWER_DBM[i] == power) {
+    for(uint8_t i = 0; i < BAUD_RATES_COUNT; i++) {
+        if(POWER_DBM[i] == module->transmitting_power) {
+            return i;
+        }
+    }
+    return 0;
+}
+
+uint8_t uhf_settings_get_module_working_region_index(M100Module* module){
+    for(uint8_t i = 0; i < WORKING_REGIONS_COUNT; i++) {
+        if(WORKING_REGIONS[i] == module->region) {
             return i;
         }
     }
@@ -44,23 +74,36 @@ void uhf_scene_settings_on_enter(void* ctx) {
     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->baudrate);
-
     item = variable_item_list_add(
         variable_item_list,
         "Baudrate:",
-        sizeof(BAUD_RATES),
+        BAUD_RATES_COUNT,
         uhf_settings_set_module_baudrate,
         uhf_module);
 
     variable_item_set_current_value_text(item, text_buf);
     variable_item_set_current_value_index(item, value_index);
 
+    value_index = uhf_settings_get_module_power_index(uhf_module);
     item = variable_item_list_add(
         variable_item_list,
         "Power(DBM):",
-        sizeof(POWER_DBM),
+        POWER_DBM_COUNT,
         uhf_settings_set_module_powerdb,
         uhf_module);
+    snprintf(text_buf, sizeof(text_buf), "%ddBm", uhf_module->transmitting_power);
+    variable_item_set_current_value_text(item, text_buf);
+    variable_item_set_current_value_index(item, value_index);
+
+    value_index = uhf_settings_get_module_working_region_index(uhf_module);
+    item = variable_item_list_add(
+        variable_item_list,
+        "Region:",
+        WORKING_REGIONS_COUNT,
+        uhf_settings_set_module_working_region,
+        uhf_module);
+    
+    variable_item_set_current_value_text(item, WORKING_REGIONS_STR[value_index]);
 
     view_dispatcher_switch_to_view(uhf_app->view_dispatcher, UHFViewVariableItemList);
 }

uhf_module.c

@@ -15,16 +15,24 @@ void rx_callback(UartIrqEvent event, uint8_t data, void* ctx) {
     tick = WAIT_TICK; // reset tick
 }
 
-static void setup_and_send_rx(M100Module* module, uint8_t* cmd, size_t cmd_length) {
+static M100ResponseType setup_and_send_rx(M100Module* module, uint8_t* cmd, size_t cmd_length) {
     buffer_reset(module->buf);
-    // furi_hal_uart_set_br(FuriHalUartIdUSART1, module->baudrate);
-    // furi_hal_uart_set_irq_cb(FuriHalUartIdUSART1, rx_callback, module->buf);
     tick = WAIT_TICK;
     furi_hal_uart_tx(FuriHalUartIdUSART1, cmd, cmd_length);
     while(--tick) {
         furi_delay_us(5);
     }
     buffer_close(module->buf);
+    // Validation Checks
+    uint8_t* data = buffer_get_data(module->buf);
+    size_t length = buffer_get_size(module->buf);
+    // check if size > 0
+    if(!length) return M100EmptyResponse;
+    // check if data is valid
+    if(data[0] != FRAME_START || data[length - 1] != FRAME_END) return M100ValidationFail;
+    // check if checksum is correct
+    if(checksum(data + 1, length - 3) != data[length - 2]) return M100ChecksumFail;
+    return M100SuccessResponse;
 }
 
 M100ModuleInfo* m100_module_info_alloc() {
@@ -43,7 +51,8 @@ M100Module* m100_module_alloc() {
     module->info = m100_module_info_alloc();
     module->buf = buffer_alloc(MAX_BUFFER_SIZE);
     module->baudrate = DEFAULT_BAUDRATE;
-    // module->area = DEFAULT_AREA;
+    module->transmitting_power = DEFAULT_TRANSMITTING_POWER;
+    module->region = DEFAULT_WORKING_REGION;
     furi_hal_uart_set_irq_cb(FuriHalUartIdUSART1, rx_callback, module->buf);
     return module;
 }
@@ -120,9 +129,6 @@ M100ResponseType m100_single_poll(M100Module* module, UHFTag* uhf_tag) {
     setup_and_send_rx(module, (uint8_t*)&CMD_SINGLE_POLLING.cmd[0], CMD_SINGLE_POLLING.length);
     uint8_t* data = buffer_get_data(module->buf);
     size_t length = buffer_get_size(module->buf);
-    for(size_t i = 0; i < length; i++) {
-        FURI_LOG_E("TAG", "data[%d] = %02X", i, data[i]);
-    }
     if(length <= 8 && data[2] == 0xFF) return M100NoTagResponse;
     uint16_t pc = data[6];
     uint16_t crc = 0;
@@ -144,7 +150,7 @@ M100ResponseType m100_single_poll(M100Module* module, UHFTag* uhf_tag) {
     uhf_tag_set_epc_pc(uhf_tag, pc);
     uhf_tag_set_epc_crc(uhf_tag, crc);
     uhf_tag_set_epc(uhf_tag, data + 8, epc_len);
-    return M100Success;
+    return M100SuccessResponse;
 }
 
 M100ResponseType m100_set_select(M100Module* module, UHFTag* uhf_tag) {
@@ -183,7 +189,7 @@ M100ResponseType m100_set_select(M100Module* module, UHFTag* uhf_tag) {
     if(checksum(data + 1, 5) != data[6]) return M100ValidationFail; // error in rx
     if(data[5] != 0x00) return M100ValidationFail; // error if not 0
 
-    return M100Success;
+    return M100SuccessResponse;
 }
 
 UHFTag* m100_get_select_param(M100Module* module) {
@@ -208,9 +214,9 @@ M100ResponseType m100_read_label_data_storage(
     uint32_t access_pwd,
     uint16_t word_count) {
     /*
-    Will probably remove UHFTag as param and get it from get selected tag
-        */
-    if(bank == EPCBank) return M100Success;
+        Will probably remove UHFTag as param and get it from get selected tag
+    */
+    if(bank == EPCBank) return M100SuccessResponse;
     uint8_t cmd[MAX_BUFFER_SIZE];
     size_t cmd_length = CMD_READ_LABEL_DATA_STORAGE_AREA.length;
     memcpy(cmd, CMD_READ_LABEL_DATA_STORAGE_AREA.cmd, cmd_length);
@@ -227,30 +233,30 @@ M100ResponseType m100_read_label_data_storage(
     // calc checksum
     cmd[cmd_length - 2] = checksum(cmd + 1, cmd_length - 3);
 
-    setup_and_send_rx(module, cmd, cmd_length);
+    while(setup_and_send_rx(module, cmd, cmd_length) != M100SuccessResponse) {
+    }
 
     uint8_t* data = buffer_get_data(module->buf);
+
+    uint8_t rtn_command = data[2];
     uint16_t payload_len = data[3];
     payload_len = (payload_len << 8) + data[4];
-    size_t ptr_offset = 5 /*<-ptr offset*/ + uhf_tag->epc->size + 3 /*<-pc + ul*/;
-    size_t bank_data_length = payload_len - (ptr_offset - 5 /*dont include the offset*/);
-    // print paylod length ptr offset and bank data length
-    // FURI_LOG_E(
-    //     "TAG",
-    //     "payload_len: %d, ptr_offset: %d, bank_data_length: %d",
-    //     payload_len,
-    //     ptr_offset,
-    //     bank_data_length);
-    if(data[2] == 0xFF) {
-        if(payload_len == 0x0001) return M100NoTagResponse;
+
+    if(rtn_command == 0xFF) {
+        if(payload_len == 0x01) return M100NoTagResponse;
         return M100MemoryOverrun;
     }
+
+    size_t ptr_offset = 5 /*<-ptr offset*/ + uhf_tag_get_epc_size(uhf_tag) + 3 /*<-pc + ul*/;
+    size_t bank_data_length = payload_len - (ptr_offset - 5 /*dont include the offset*/);
+
     if(bank == TIDBank) {
         uhf_tag_set_tid(uhf_tag, data + ptr_offset, bank_data_length);
     } else if(bank == UserBank) {
         uhf_tag_set_user(uhf_tag, data + ptr_offset, bank_data_length);
     }
-    return M100Success;
+
+    return M100SuccessResponse;
 }
 
 M100ResponseType m100_write_label_data_storage(
@@ -325,7 +331,7 @@ M100ResponseType m100_write_label_data_storage(
         return M100NoTagResponse;
     else if(buff_data[2] == 0xFF)
         return M100ValidationFail;
-    return M100Success;
+    return M100SuccessResponse;
 }
 void m100_set_baudrate(M100Module* module, uint32_t baudrate) {
     size_t length = CMD_SET_COMMUNICATION_BAUD_RATE.length;
@@ -340,28 +346,27 @@ void m100_set_baudrate(M100Module* module, uint32_t baudrate) {
     module->baudrate = baudrate;
 }
 
-bool m100_set_working_area(M100Module* module, WorkingArea area) {
+bool m100_set_working_region(M100Module* module, WorkingRegion region) {
     size_t length = CMD_SET_WORK_AREA.length;
     uint8_t cmd[length];
     memcpy(cmd, CMD_SET_WORK_AREA.cmd, length);
-    cmd[5] = area;
-    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);
-    module->area = area;
+    cmd[5] = (uint8_t)region;
+    cmd[length - 2] = checksum(cmd + 1, length - 3);
+    setup_and_send_rx(module, cmd, length);
+    module->region = region;
     return true;
 }
 
-bool m100_set_working_channel(M100Module* module, WorkingChannel channel) {
-    UNUSED(module);
-    UNUSED(channel);
-    return true;
-}
 
 bool m100_set_transmitting_power(M100Module* module, uint16_t power) {
-    UNUSED(module);
-    UNUSED(power);
+    size_t length = CMD_SET_TRANSMITTING_POWER.length;
+    uint8_t cmd[length];
+    memcpy(cmd, CMD_SET_TRANSMITTING_POWER.cmd, length);
+    cmd[5] = (power >> 8) & 0xFF;
+    cmd[6] = power & 0xFF;
+    cmd[length - 2] = checksum(cmd + 1, length - 3);
+    setup_and_send_rx(module, cmd, length);
+    module->transmitting_power = power;
     return true;
 }
 

uhf_module.h

@@ -8,8 +8,11 @@
 #include <furi_hal.h>
 #include "uhf_module_settings.h"
 
+#define FRAME_START 0xBB
 #define FRAME_END 0x7E
-#define DEFAULT_BAUDRATE 115200
+#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
 
 typedef struct {
     char* hw_version;
@@ -18,17 +21,19 @@ typedef struct {
 } M100ModuleInfo;
 
 typedef enum {
-    M100Success,
+    M100SuccessResponse,
     M100ValidationFail,
     M100NoTagResponse,
-    M100MemoryOverrun
+    M100MemoryOverrun,
+    M100EmptyResponse,
+    M100ChecksumFail
 } M100ResponseType;
 
 typedef struct {
     M100ModuleInfo* info;
     uint32_t baudrate;
-    WorkingArea area;
-    WorkingChannel channel;
+    WorkingRegion region;
+    uint16_t region_frequency;
     uint16_t transmitting_power;
     bool freq_hopping;
     Buffer* buf;
@@ -48,8 +53,7 @@ char* m100_get_software_version(M100Module* module);
 char* m100_get_manufacturers(M100Module* module);
 
 void m100_set_baudrate(M100Module* module, uint32_t baudrate);
-bool m100_set_working_area(M100Module* module, WorkingArea area);
-bool m100_set_working_channel(M100Module* module, WorkingChannel channel);
+bool m100_set_working_region(M100Module* module, WorkingRegion region);
 bool m100_set_transmitting_power(M100Module* module, uint16_t power);
 bool m100_set_freq_hopping(M100Module* module, bool hopping);
 bool m100_set_power(M100Module* module, uint8_t* power);

uhf_module_cmd.h

@@ -26,6 +26,7 @@ static const uint8_t CMD_SET_COMMUNICATION_BAUD_RATE_DATA[] = {0xBB, 0x00, 0x11,
 static const uint8_t CMD_GET_QUERY_PARAMETERS_DATA[] = {0xBB, 0x00, 0x0D, 0x00, 0x00, 0x0D, 0x7E};
 static const uint8_t CMD_SET_QUERY_PARAMETER_DATA[] = {0xBB, 0x00, 0x0E, 0x00, 0x02, 0x10, 0x20, 0x40, 0x7E};
 static const uint8_t CMD_SET_WORK_AREA_DATA[] = {0xBB, 0x00, 0x07, 0x00, 0x01, 0x01, 0x09, 0x7E};
+static const uint8_t CMD_SET_TRANSMITTING_POWER_DATA[] = {0xBB, 0x00, 0xB6, 0x00, 0x02, 0x07, 0xD0, 0x8F, 0x7E};
 
 
 // Define the Command structs
@@ -46,3 +47,4 @@ static const Command CMD_SET_COMMUNICATION_BAUD_RATE = {CMD_SET_COMMUNICATION_BA
 static const Command CMD_GET_QUERY_PARAMETERS = {CMD_GET_QUERY_PARAMETERS_DATA, sizeof(CMD_GET_QUERY_PARAMETERS_DATA)};
 static const Command CMD_SET_QUERY_PARAMETER = {CMD_SET_QUERY_PARAMETER_DATA, sizeof(CMD_SET_QUERY_PARAMETER_DATA)};
 static const Command CMD_SET_WORK_AREA = {CMD_SET_WORK_AREA_DATA, sizeof(CMD_SET_WORK_AREA_DATA)};
+static const Command CMD_SET_TRANSMITTING_POWER = {CMD_SET_TRANSMITTING_POWER_DATA, sizeof(CMD_SET_TRANSMITTING_POWER_DATA)};

uhf_module_settings.h

@@ -2,25 +2,27 @@
 
 #include <stdint.h>
 
-// UHF module baudrates
-static const uint32_t BAUD_RATES[] = {9600, 19200, 115200};
-
 // UHF module regions
 typedef enum {
-    WA_CHINA_900 = 1, // Freq_CH-920.125M
-    WA_US, // Freq_CH-902.25M
-    WA_EU, // Freq_CH-865.1M
-    WA_CHINA_800, // Freq_CH-840.125M
-    WA_KOREA = 6 // Freq_CH-917.1M
-} WorkingArea;
-
-typedef enum {
-    WC_CHINA_900 = 1, // CH_Index(CN,900MHz) = (Freq_CH-920.125M)/0.25M
-    WC_US, // CH_Index(US) = (Freq_CH-902.25M)/0.5M
-    WC_EU, // CH_Index(EU) = (Freq_CH-865.1M)/0.2M
-    WC_CHINA_800, // CH_Index(CN,800MHz) = (Freq_CH-840.125M)/0.25M
-    WC_KOREA = 6 // CH_Index(Korea) = (Freq_CH-917.1M)/0.2M
-} WorkingChannel;
+    WR_CHINA_900 = 1, // Freq_CH-920.125M
+    WR_US, // Freq_CH-902.25M
+    WR_EU, // Freq_CH-865.1M
+    WR_CHINA_800, // Freq_CH-840.125M
+    WR_KOREA = 6 // Freq_CH-917.1M
+} WorkingRegion;
 
+// UHF module baudrates
+static const uint32_t BAUD_RATES[] = {9600, 19200, 115200};
+static const uint8_t BAUD_RATES_COUNT = sizeof(BAUD_RATES) / sizeof(BAUD_RATES[0]);
 // RF Power Setting
-static const uint8_t POWER_DBM[] = {12, 14, 17, 20}; // To be determined ...
+static const uint8_t POWER_DBM[] = {12, 14, 17, 20}; // To be determined ...
+static const uint8_t POWER_DBM_COUNT = sizeof(POWER_DBM) / sizeof(POWER_DBM[0]);
+// UHF WorkingArea
+static const char* WORKING_REGIONS_STR[] = {"China(900)MHz", "US", "EU", "China(800)MHz", "Korea"};
+static const uint8_t __working_region_str = sizeof(WORKING_REGIONS_STR) / sizeof(WORKING_REGIONS_STR[0]);
+static const WorkingRegion WORKING_REGIONS[] = {WR_CHINA_900, WR_US, WR_EU, WR_CHINA_800, WR_KOREA};
+static const uint8_t WORKING_REGIONS_COUNT = sizeof(WORKING_REGIONS) / sizeof(WORKING_REGIONS[0]);
+// UHF WorkingChannel
+// static const string WORKING_CHANNELS_STR[] = {"China 900MHz", "US", "EU", "China 800MHz", "Korea"};
+// static const WorkingChannel WORKING_CHANNELS[] = {WC_CHINA_900, WC_US, WC_EU, WC_CHINA_800, WC_KOREA};
+// static const uint8_t WORKING_CHANNELS_COUNT = sizeof(WORKING_CHANNELS) / sizeof(WORKING_CHANNELS[0]);

uhf_worker.c

@@ -20,7 +20,7 @@ UHFTag* send_polling_command(UHFWorker* uhf_worker) {
             uhf_tag_free(uhf_tag);
             return NULL;
         }
-        if(status == M100Success) break;
+        if(status == M100SuccessResponse) break;
     }
     return uhf_tag;
 }
@@ -34,16 +34,14 @@ UHFWorkerEvent read_bank_till_max_length(UHFWorker* uhf_worker, UHFTag* uhf_tag,
         if(word_low >= word_high) return UHFWorkerEventSuccess;
         word_size = (word_low + word_high) / 2;
         status = m100_read_label_data_storage(uhf_worker->module, uhf_tag, bank, 0, word_size);
-        if(status == M100Success) {
+        if(status == M100SuccessResponse) {
             word_low = word_size + 1;
         } else if(status == M100MemoryOverrun) {
             word_high = word_size - 1;
         } else if(status == M100NoTagResponse) {
             retry--;
         }
-        FURI_LOG_E("TAG", "read bank %d, word_low %d, word_high %d", bank, word_low, word_high);
     } while(retry);
-    FURI_LOG_E("TAG", "read success; retry = %d", retry);
     if(!retry) return UHFWorkerEventFail;
     return UHFWorkerEventSuccess;
 }
@@ -53,7 +51,8 @@ UHFWorkerEvent read_single_card(UHFWorker* uhf_worker) {
     if(uhf_tag == NULL) return UHFWorkerEventAborted;
     uhf_tag_wrapper_set_tag(uhf_worker->uhf_tag_wrapper, uhf_tag);
     // set select
-    if(m100_set_select(uhf_worker->module, uhf_tag) != M100Success) return UHFWorkerEventFail;
+    if(m100_set_select(uhf_worker->module, uhf_tag) != M100SuccessResponse)
+        return UHFWorkerEventFail;
     // read tid
     UHFWorkerEvent event;
     event = read_bank_till_max_length(uhf_worker, uhf_tag, TIDBank);
@@ -68,18 +67,19 @@ UHFWorkerEvent write_single_card(UHFWorker* uhf_worker) {
     UHFTag* uhf_tag_des = send_polling_command(uhf_worker);
     if(uhf_tag_des == NULL) return UHFWorkerEventAborted;
     UHFTag* uhf_tag_from = uhf_worker->uhf_tag_wrapper->uhf_tag;
-    if(m100_set_select(uhf_worker->module, uhf_tag_des) != M100Success) return UHFWorkerEventFail;
+    if(m100_set_select(uhf_worker->module, uhf_tag_des) != M100SuccessResponse)
+        return UHFWorkerEventFail;
     do {
         M100ResponseType 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 == M100Success) break;
+        if(rp_type == M100SuccessResponse) break;
     } while(true);
     do {
         M100ResponseType 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 == M100Success) break;
+        if(rp_type == M100SuccessResponse) break;
     } while(true);
     return UHFWorkerEventSuccess;
 }
@@ -91,9 +91,7 @@ int32_t uhf_worker_task(void* ctx) {
         uhf_worker->callback(event, uhf_worker->ctx);
     } else if(uhf_worker->state == UHFWorkerStateDetectSingle) {
         UHFWorkerEvent event = read_single_card(uhf_worker);
-        FURI_LOG_E("TAG", "read single card success");
         uhf_worker->callback(event, uhf_worker->ctx);
-        FURI_LOG_E("TAG", "read single card callback success %d", event);
     } else if(uhf_worker->state == UHFWorkerStateWriteSingle) {
         UHFWorkerEvent event = write_single_card(uhf_worker);
         uhf_worker->callback(event, uhf_worker->ctx);