Merge pull request #939 from Dmitry422/dev

Subghz counter editor refactor

Author: xMasterX

applications/examples/example_event_loop/example_event_loop_mutex.c

@@ -26,7 +26,7 @@ typedef struct {
     uint8_t worker_result;
 } EventLoopMutexApp;
 
-// This funciton is being run in a separate thread to simulate lenghty blocking operations
+// This funciton is being run in a separate thread to simulate lengthy blocking operations
 static int32_t event_loop_mutex_app_worker_thread(void* context) {
     furi_assert(context);
     EventLoopMutexApp* app = context;

applications/main/subghz/scenes/subghz_scene_signal_settings.c

@@ -4,16 +4,15 @@
 #include <lib/toolbox/value_index.h>
 #include <machine/endian.h>
 #include <toolbox/strint.h>
+#include <lib/subghz/blocks/generic.h>
 
 #define TAG "SubGhzSceneSignalSettings"
 
 static uint32_t counter_mode = 0xff;
-static uint32_t loaded_counter32 = 0x0;
 static uint32_t counter32 = 0x0;
 static uint16_t counter16 = 0x0;
 static uint8_t byte_count = 0;
 static uint8_t* byte_ptr = NULL;
-static uint8_t hex_char_lenght = 0;
 static FuriString* byte_input_text;
 
 #define COUNTER_MODE_COUNT 7
@@ -52,55 +51,6 @@ static Protocols protocols[] = {
 
 #define PROTOCOLS_COUNT (sizeof(protocols) / sizeof(Protocols));
 
-// our special case function based on strint_to_uint32 from strint.c
-StrintParseError strint_to_uint32_base16(const char* str, uint32_t* out, uint8_t* lenght) {
-    // skip whitespace
-    while(((*str >= '\t') && (*str <= '\r')) || *str == ' ') {
-        str++;
-    }
-
-    // read digits
-    uint32_t limit = UINT32_MAX;
-    uint32_t mul_limit = limit / 16;
-    uint32_t result = 0;
-    int read_total = 0;
-
-    while(*str != 0) {
-        int digit_value;
-        if(*str >= '0' && *str <= '9') {
-            digit_value = *str - '0';
-        } else if(*str >= 'A' && *str <= 'Z') {
-            digit_value = *str - 'A' + 10;
-        } else if(*str >= 'a' && *str <= 'z') {
-            digit_value = *str - 'a' + 10;
-        } else {
-            break;
-        }
-
-        if(digit_value >= 16) {
-            break;
-        }
-
-        if(result > mul_limit) return StrintParseOverflowError;
-        result *= 16;
-        if(result > limit - digit_value) return StrintParseOverflowError; //-V658
-        result += digit_value;
-
-        read_total++;
-        str++;
-    }
-
-    if(read_total == 0) {
-        result = 0;
-        *lenght = 0;
-        return StrintParseAbsentError;
-    }
-
-    if(out) *out = result;
-    if(lenght) *lenght = read_total;
-    return StrintParseNoError;
-}
-
 void subghz_scene_signal_settings_counter_mode_changed(VariableItem* item) {
     uint8_t index = variable_item_get_current_value_index(item);
     variable_item_set_current_value_text(item, counter_mode_text[index]);
@@ -117,8 +67,8 @@ void subghz_scene_signal_settings_variable_item_list_enter_callback(void* contex
 
     // when we click OK on "Edit counter" item
     if(index == 1) {
-        furi_string_cat_printf(byte_input_text, "%i", hex_char_lenght * 4);
-        furi_string_cat_str(byte_input_text, "-bit counter in HEX");
+        furi_string_cat_printf(byte_input_text, "%i", subghz_block_generic_global.cnt_length_bit);
+        furi_string_cat_str(byte_input_text, "-bits counter in HEX");
 
         // Setup byte_input view
         ByteInput* byte_input = subghz->byte_input;
@@ -174,93 +124,45 @@ void subghz_scene_signal_settings_on_enter(void* context) {
             }
         }
     }
-    FURI_LOG_D(TAG, "Current CounterMode value %li", counter_mode);
+    FURI_LOG_D(TAG, "Loaded CounterMode value %li", counter_mode);
 
     flipper_format_file_close(fff_data_file);
     flipper_format_free(fff_data_file);
     furi_record_close(RECORD_STORAGE);
 
     // ### Counter edit section ###
-    FuriString* textCnt = furi_string_alloc_set_str("");
     byte_input_text = furi_string_alloc_set_str("Enter ");
-    furi_string_reset(tmp_text);
-
     bool counter_not_available = true;
     SubGhzProtocolDecoderBase* decoder = subghz_txrx_get_decoder(subghz->txrx);
 
-    // deserialaze and decode loaded sugbhz file and take information string from decoder
+    // deserialaze and decode loaded sugbhz file and push data to subghz_block_generic_global variable
     if(subghz_protocol_decoder_base_deserialize(decoder, subghz_txrx_get_fff_data(subghz->txrx)) ==
        SubGhzProtocolStatusOk) {
         subghz_protocol_decoder_base_get_string(decoder, tmp_text);
     } else {
         FURI_LOG_E(TAG, "Cant deserialize this subghz file");
     }
 
-    // In protocols output we allways have HEX format for "Cnt:" output (text formating like ...Cnt:%05lX\r\n")
-    // we take 8 symbols starting from  "Cnt:........"
-    // at first we search "Cnt:????" that means for this protocol counter cannot be decoded
-
-    int8_t place = furi_string_search_str(tmp_text, "Cnt:??", 0);
-    if(place > 0) {
+    if(!subghz_block_generic_global.cnt_is_available) {
         counter_mode = 0xff;
-        FURI_LOG_D(TAG, "Found Cnt:???? - Counter mode and edit not available for this protocol");
+        FURI_LOG_D(TAG, "Counter mode and edit not available for this protocol");
     } else {
-        place = furi_string_search_str(tmp_text, "Cnt:", 0);
-        if(place > 0) {
-            // defence from memory leaks. Check can we take 8 symbols after 'Cnt:' ?
-            // if from current place to end of stirngs more than 8 symbols - ok, if not - just take symbols from current place to end of string.
-            // +4 - its 'Cnt:' lenght
-            uint8_t n_symbols_taken = 8;
-            if(sizeof(tmp_text) - (place + 4) < 8) {
-                n_symbols_taken = sizeof(tmp_text) - (place + 4);
-            }
-            furi_string_set_n(textCnt, tmp_text, place + 4, n_symbols_taken);
-            furi_string_trim(textCnt);
-            FURI_LOG_D(
-                TAG,
-                "Took 8 bytes hex value starting after 'Cnt:' - %s",
-                furi_string_get_cstr(textCnt));
-
-            // trim and convert 8 simbols string to uint32 by base 16 (hex);
-            // later we use loaded_counter in subghz_scene_signal_settings_on_event to check is there 0 or not - special case
-
-            if(strint_to_uint32_base16(
-                   furi_string_get_cstr(textCnt), &loaded_counter32, &hex_char_lenght) ==
-               StrintParseNoError) {
-                counter_not_available = false;
-
-                // calculate and roundup number of hex bytes to display counter in byte_input (every 2 hex symbols = 1 byte for view)
-                // later must be used in byte_input to restrict number of available byte to edit
-                // cnt_byte_count = (hex_char_lenght + 1) / 2;
-
-                FURI_LOG_D(
-                    TAG,
-                    "Result of conversion from String to uint_32 DEC %li, HEX %lX, HEX length %i symbols",
-                    loaded_counter32,
-                    loaded_counter32,
-                    hex_char_lenght);
-
-                // Check is there byte_count more than 2 hex bytes long (16 bit) or not (32bit)
-                // To show hex value we must correct revert bytes for ByteInput view
-                if(hex_char_lenght > 4) {
-                    counter32 = loaded_counter32;
-                    furi_string_printf(tmp_text, "%lX", counter32);
-                    counter32 = __bswap32(counter32);
-                    byte_ptr = (uint8_t*)&counter32;
-                    byte_count = 4;
-                } else {
-                    counter16 = loaded_counter32;
-                    furi_string_printf(tmp_text, "%X", counter16);
-                    counter16 = __bswap16(counter16);
-                    byte_ptr = (uint8_t*)&counter16;
-                    byte_count = 2;
-                }
-            } else {
-                FURI_LOG_E(TAG, "Cant convert text counter value");
-            };
-
+        counter_not_available = false;
+
+        // Check is there byte_count more than 2 hex bytes long or not
+        // To show hex value we must correct revert bytes for ByteInput view with __bswapХХ
+        if(subghz_block_generic_global.cnt_length_bit > 16) {
+            counter32 = subghz_block_generic_global.current_cnt;
+            furi_string_printf(tmp_text, "%lX", counter32);
+            counter32 = __bswap32(counter32);
+            byte_ptr = (uint8_t*)&counter32;
+            byte_count = 4;
         } else {
-            FURI_LOG_D(TAG, "Counter editor not available for this protocol");
+            counter16 = subghz_block_generic_global.current_cnt;
+            furi_string_printf(tmp_text, "%X", counter16);
+            counter16 = __bswap16(counter16);
+            byte_ptr = (uint8_t*)&counter16;
+            byte_count = 2;
         }
     }
 
@@ -272,9 +174,6 @@ void subghz_scene_signal_settings_on_enter(void* context) {
     int32_t value_index;
     VariableItem* item;
 
-    // variable_item_list_set_selected_item(subghz->variable_item_list, 0);
-    // variable_item_list_reset(subghz->variable_item_list);
-
     variable_item_list_set_enter_callback(
         variable_item_list,
         subghz_scene_signal_settings_variable_item_list_enter_callback,
@@ -298,71 +197,29 @@ void subghz_scene_signal_settings_on_enter(void* context) {
     variable_item_set_locked(item, (counter_not_available), "Not available\nfor this\nprotocol !");
 
     furi_string_free(tmp_text);
-    furi_string_free(textCnt);
 
     view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdVariableItemList);
 }
 
 bool subghz_scene_signal_settings_on_event(void* context, SceneManagerEvent event) {
     SubGhz* subghz = context;
-    int32_t tmp_counter = 0;
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == SubGhzCustomEventByteInputDone) {
             switch(byte_count) {
             case 2:
-                // when signal has Cnt:00 we can step only to 0000+FFFF = FFFF, but we need 0000 for next step
-                // for this case we must use +1 additional step to increace Cnt from FFFF to 0000.
-
-                // save current user defined counter increase value (mult)
-                tmp_counter = furi_hal_subghz_get_rolling_counter_mult();
-
-                // increase signal counter to max value - at result it must be 0000 in most cases
-                // but can be FFFF in case Cnt:0000 (for this we have +1 additional step below)
-                furi_hal_subghz_set_rolling_counter_mult(0xFFFF);
-                subghz_tx_start(subghz, subghz_txrx_get_fff_data(subghz->txrx));
-                subghz_txrx_stop(subghz->txrx);
-
-                // if file Cnt:00 then do +1 additional step
-                if(loaded_counter32 == 0) {
-                    furi_hal_subghz_set_rolling_counter_mult(1);
-                    subghz_tx_start(subghz, subghz_txrx_get_fff_data(subghz->txrx));
-                    subghz_txrx_stop(subghz->txrx);
-                }
-
-                // at this point we must have signal Cnt:00
-                // convert back after byte_input and do one send with our new mult (counter16) - at end we must have signal Cnt = counter16
+                // set new cnt value and override_flag to global variable and call transmit to generate and save subghz signal
                 counter16 = __bswap16(counter16);
-
-                furi_hal_subghz_set_rolling_counter_mult(counter16);
+                subghz_block_generic_global_counter_override_set(counter16);
                 subghz_tx_start(subghz, subghz_txrx_get_fff_data(subghz->txrx));
                 subghz_txrx_stop(subghz->txrx);
-
-                // restore user definded counter increase value (mult)
-                furi_hal_subghz_set_rolling_counter_mult(tmp_counter);
-
                 break;
             case 4:
                 // the same for 32 bit Counter
-                tmp_counter = furi_hal_subghz_get_rolling_counter_mult();
-
-                furi_hal_subghz_set_rolling_counter_mult(0xFFFFFFF);
-                subghz_tx_start(subghz, subghz_txrx_get_fff_data(subghz->txrx));
-                subghz_txrx_stop(subghz->txrx);
-
-                if(loaded_counter32 == 0) {
-                    furi_hal_subghz_set_rolling_counter_mult(1);
-                    subghz_tx_start(subghz, subghz_txrx_get_fff_data(subghz->txrx));
-                    subghz_txrx_stop(subghz->txrx);
-                }
-
                 counter32 = __bswap32(counter32);
-
-                furi_hal_subghz_set_rolling_counter_mult((counter32 & 0xFFFFFFF));
+                subghz_block_generic_global_counter_override_set(counter32);
                 subghz_tx_start(subghz, subghz_txrx_get_fff_data(subghz->txrx));
                 subghz_txrx_stop(subghz->txrx);
-
-                furi_hal_subghz_set_rolling_counter_mult(tmp_counter);
                 break;
             default:
                 break;

lib/mjs/mjs_exec.c

@@ -1063,7 +1063,7 @@ MJS_PRIVATE mjs_err_t mjs_execute(struct mjs* mjs, size_t off, mjs_val_t* res) {
 
             mjs_gen_stack_trace(mjs, bp.start_idx + i - 1 /* undo the i++ */);
 
-            /* restore stack lenghts */
+            /* restore stack lengths */
             mjs->stack.len = stack_len;
             mjs->call_stack.len = call_stack_len;
             mjs->arg_stack.len = arg_stack_len;

lib/subghz/blocks/generic.c

@@ -4,6 +4,35 @@
 
 #define TAG "SubGhzBlockGeneric"
 
+// Main things: subghz protocols working (serialize, deserialize, decode and encode)
+// with flipper_format data isolated from upper level subghz functions and structures.
+// So if we need change something inside of protocol data - we need use this API from protocols to get and set data
+
+SubGhzBlockGenericGlobal subghz_block_generic_global; //global structure for subghz
+
+void subghz_block_generic_global_counter_override_set(uint32_t counter) {
+    subghz_block_generic_global.new_cnt = counter; // set global variable
+    subghz_block_generic_global.cnt_need_override = true; // set flag for protocols
+}
+
+bool subghz_block_generic_global_counter_override_get(uint32_t* counter) {
+    // if override flag was enabled then return succes TRUE and return overrided counter, else return success = FALSE
+    // we cut counter bit length to available protocol bits length by the logical AND function
+    if(subghz_block_generic_global.cnt_need_override) {
+        *counter = subghz_block_generic_global.new_cnt &
+                   ((0xFFFFFFFF >> (32 - subghz_block_generic_global.cnt_length_bit)));
+        subghz_block_generic_global.cnt_need_override = false;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+void subghz_block_generic_global_reset(void* p) {
+    UNUSED(p);
+    memset(&subghz_block_generic_global, 0, sizeof(subghz_block_generic_global));
+}
+
 void subghz_block_generic_get_preset_name(const char* preset_name, FuriString* preset_str) {
     const char* preset_name_temp;
     if(!strcmp(preset_name, "AM270")) {

lib/subghz/blocks/generic.h

@@ -27,6 +27,36 @@ struct SubGhzBlockGeneric {
     uint32_t seed;
 };
 
+typedef struct SubGhzBlockGenericGlobal SubGhzBlockGenericGlobal;
+
+struct SubGhzBlockGenericGlobal {
+    uint32_t current_cnt; // global counter value;
+    uint32_t new_cnt; // global counter value;
+    bool cnt_need_override; // flag for protocols to override signals counter inside of protocols
+    uint8_t cnt_length_bit; // counter length in bytes (used in counter editor giu)
+    bool cnt_is_available; // is there counter available for protocol (used in counter editor giu)
+};
+
+extern SubGhzBlockGenericGlobal subghz_block_generic_global; //global structure for subghz
+
+/**
+ * Setup SubGhzBlockGenericGlobal.cnt and cnt_need_override flag to be used in protocols;
+ * @param counter new counter value;
+ */
+void subghz_block_generic_global_counter_override_set(uint32_t counter);
+
+/**
+ * Return true if incomming variable was overrided by SubGhzBlockGenericGlobal.cnt
+ * else return false and not change incomming variable
+ * @param counter pointer to counter variable that must be changed
+ */
+bool subghz_block_generic_global_counter_override_get(uint32_t* counter);
+
+/**
+ * Reset subghz_block_generic global structure;
+ */
+void subghz_block_generic_global_reset(void* p);
+
 /**
  * Get name preset.
  * @param preset_name name preset