Subghz counter editor refactor

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_printf(byte_input_text, "%i", subghz_block_generic_global.cnt_lenght_bit);
-        furi_string_cat_str(byte_input_text, "-bit counter in HEX");
+        furi_string_cat_str(byte_input_text, "-bits counter in HEX");
 
         // Setup byte_input view
         ByteInput* byte_input = subghz->byte_input;
@@ -174,21 +124,18 @@ 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);
@@ -196,72 +143,26 @@ void subghz_scene_signal_settings_on_enter(void* context) {
         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")
+    if(!subghz_block_generic_global.cnt_is_available) {
-    // we take 8 simbols starting from  "Cnt:........"
-    // at first we search "Cnt:????" that mean for this protocol counter cannot be decoded
-
-    int8_t place = furi_string_search_str(tmp_text, "Cnt:??", 0);
-    if(place > 0) {
         counter_mode = 0xff;
-        FURI_LOG_D(
+        FURI_LOG_D(TAG, "Counter mode and edit not available for this protocol");
-            TAG, "Founded Cnt:???? - Counter mode and edit not available for this protocol");
     } else {
-        place = furi_string_search_str(tmp_text, "Cnt:", 0);
+        counter_not_available = false;
-        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,
-                "Taked 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 do display counter in byte_input (every 2 hex simbols = 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 lenght %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");
-            };
 
+        // 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_lenght_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;
         }
     }
 
@@ -273,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,
@@ -299,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
+                // set new cnt value and override_flag to global variable and call transmit to generate and save subghz signal
-                // for this case we must use +1 additional step to increace Cnt from FFFF to 0000.
-
-                // save current user definded 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
                 counter16 = __bswap16(counter16);
-
+                subghz_block_generic_global_counter_override_set(counter16);
-                furi_hal_subghz_set_rolling_counter_mult(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);
-
+                subghz_block_generic_global_counter_override_set(counter32);
-                furi_hal_subghz_set_rolling_counter_mult((counter32 & 0xFFFFFFF));
                 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/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 lenght to available protocol bits lenght 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_lenght_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_lenght_bit; // counter lenght 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

lib/subghz/protocols/alutech_at_4n.c

@@ -278,12 +278,17 @@ static bool subghz_protocol_alutech_at_4n_gen_data(
     if(alutech_at4n_counter_mode == 0) {
         // Check for OFEX (overflow experimental) mode
         if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
-            if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+            // standart counter mode. PULL data from subghz_block_generic_global variables
-                instance->generic.cnt = 0;
+            if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
-            } else {
+                // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
-                instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+                if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+                    instance->generic.cnt = 0;
+                } else {
+                    instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+                }
             }
         } else {
+            //OFFEX mode
             if((instance->generic.cnt + 0x1) > 0xFFFF) {
                 instance->generic.cnt = 0;
             } else if(instance->generic.cnt >= 0x1 && instance->generic.cnt != 0xFFFE) {
@@ -870,6 +875,12 @@ void subghz_protocol_decoder_alutech_at_4n_get_string(void* context, FuriString*
     uint32_t code_found_hi = instance->generic.data >> 32;
     uint32_t code_found_lo = instance->generic.data & 0x00000000ffffffff;
 
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.cnt_lenght_bit = 16;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+    //
+
     furi_string_cat_printf(
         output,
         "%s\r\n"

lib/subghz/protocols/base.c

@@ -1,5 +1,6 @@
 #include "base.h"
 #include "registry.h"
+#include "../blocks/generic.h"
 
 void subghz_protocol_decoder_base_set_decoder_callback(
     SubGhzProtocolDecoderBase* decoder_base,
@@ -17,6 +18,8 @@ bool subghz_protocol_decoder_base_get_string(
     furi_check(decoder_base);
     furi_check(output);
 
+    subghz_block_generic_global_reset(0);
+
     bool status = false;
 
     if(decoder_base->protocol && decoder_base->protocol->decoder &&

lib/subghz/protocols/came_atomo.c

@@ -190,12 +190,17 @@ static void subghz_protocol_encoder_came_atomo_get_upload(
     if(came_atomo_counter_mode == 0) {
         // Check for OFEX (overflow experimental) mode
         if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
-            if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+            // standart counter mode. PULL data from subghz_block_generic_global variables
-                instance->generic.cnt = 0;
+            if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
-            } else {
+                // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
-                instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+                if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+                    instance->generic.cnt = 0;
+                } else {
+                    instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+                }
             }
         } else {
+            //OFFEX mode
             if((instance->generic.cnt + 0x1) > 0xFFFF) {
                 instance->generic.cnt = 0;
             } else if(instance->generic.cnt >= 0x1 && instance->generic.cnt != 0xFFFE) {
@@ -820,6 +825,12 @@ void subghz_protocol_decoder_came_atomo_get_string(void* context, FuriString* ou
     uint32_t code_found_hi = instance->generic.data >> 32;
     uint32_t code_found_lo = instance->generic.data & 0x00000000ffffffff;
 
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.cnt_lenght_bit = 16;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+    //
+
     furi_string_cat_printf(
         output,
         "%s %db\r\n"

lib/subghz/protocols/faac_slh.c

@@ -138,17 +138,19 @@ static bool subghz_protocol_faac_slh_gen_data(SubGhzProtocolEncoderFaacSLH* inst
         uint8_t data_prg[8];
 
         data_prg[0] = 0x00;
-        // faac slh protocol have 20-bit counter so we take only 20 bits from mult (by AND 0xFFFFF)
 
         if(allow_zero_seed || (instance->generic.seed != 0x0)) {
             // check OFEX mode
             if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
-                if((instance->generic.cnt +
+                // standart counter mode. PULL data from subghz_block_generic_global variables
-                    (furi_hal_subghz_get_rolling_counter_mult() & 0xFFFFF)) > 0xFFFFF) {
+                if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
-                    instance->generic.cnt = 0;
+                    // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
-                } else {
+                    if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) >
-                    instance->generic.cnt +=
+                       0xFFFFF) {
-                        (furi_hal_subghz_get_rolling_counter_mult() & 0xFFFFF);
+                        instance->generic.cnt = 0;
+                    } else {
+                        instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+                    }
                 }
             } else {
                 // to do OFEX mode
@@ -158,12 +160,15 @@ static bool subghz_protocol_faac_slh_gen_data(SubGhzProtocolEncoderFaacSLH* inst
             if(temp_counter_backup != 0x0) {
                 // check OFEX mode
                 if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
-                    if((temp_counter_backup +
+                    // standart counter mode. PULL data from subghz_block_generic_global variables
-                        (furi_hal_subghz_get_rolling_counter_mult() & 0xFFFFF)) > 0xFFFFF) {
+                    if(!subghz_block_generic_global_counter_override_get(&temp_counter_backup)) {
-                        temp_counter_backup = 0;
+                        // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
-                    } else {
+                        if((temp_counter_backup + furi_hal_subghz_get_rolling_counter_mult()) >
-                        temp_counter_backup +=
+                           0xFFFFF) {
-                            (furi_hal_subghz_get_rolling_counter_mult() & 0xFFFFF);
+                            temp_counter_backup = 0;
+                        } else {
+                            temp_counter_backup += furi_hal_subghz_get_rolling_counter_mult();
+                        }
                     }
                 } else {
                     // todo OFEX mode
@@ -234,17 +239,19 @@ static bool subghz_protocol_faac_slh_gen_data(SubGhzProtocolEncoderFaacSLH* inst
         fixx[i] = (fix >> (shiftby -= 4)) & 0xF;
     }
 
-    // faac slh protocol have 20-bit counter so we take only 20 bits from mult (by AND 0xFFFFF)
     if(allow_zero_seed || (instance->generic.seed != 0x0)) {
         // check OFEX mode
         if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
-            if((instance->generic.cnt + (furi_hal_subghz_get_rolling_counter_mult() & 0xFFFFF)) >
+            // standart counter mode. PULL data from subghz_block_generic_global variables
-               0xFFFFF) {
+            if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
-                instance->generic.cnt = 0;
+                // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
-            } else {
+                if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) >
-                instance->generic.cnt += (furi_hal_subghz_get_rolling_counter_mult() & 0xFFFFF);
+                   0xFFFFF) {
+                    instance->generic.cnt = 0;
+                } else {
+                    instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+                }
             }
-
         } else {
             // OFEX mode
             if(instance->generic.cnt < 0xFFFFF) {
@@ -745,6 +752,12 @@ void subghz_protocol_decoder_faac_slh_get_string(void* context, FuriString* outp
             instance->generic.btn,
             instance->generic.serial);
     } else {
+        // push protocol data to global variable
+        subghz_block_generic_global.cnt_is_available = true;
+        subghz_block_generic_global.cnt_lenght_bit = 20;
+        subghz_block_generic_global.current_cnt = instance->generic.cnt;
+        //
+
         furi_string_cat_printf(
             output,
             "%s %dbit\r\n"

lib/subghz/protocols/hay21.c

@@ -147,11 +147,14 @@ static void subghz_protocol_encoder_hay21_get_upload(SubGhzProtocolEncoderHay21*
     // Counter increment
     // Check for OFEX (overflow experimental) mode
     if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
-        //not matter how big and long mult - we take only 4 bits ( AND 0xF) beacose hay21 counter have only 4 bits long (0..F)
+        // standart counter mode. PULL data from subghz_block_generic_global variables
-        if((instance->generic.cnt + (furi_hal_subghz_get_rolling_counter_mult() & 0xF)) > 0xF) {
+        if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
-            instance->generic.cnt = 0;
+            // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
-        } else {
+            if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xF) {
-            instance->generic.cnt += (furi_hal_subghz_get_rolling_counter_mult() & 0xF);
+                instance->generic.cnt = 0;
+            } else {
+                instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+            }
         }
     } else {
         // OFEX mode
@@ -460,6 +463,11 @@ void subghz_protocol_decoder_hay21_get_string(void* context, FuriString* output)
     // Parse serial, button, counter
     subghz_protocol_hay21_remote_controller(&instance->generic);
 
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.cnt_lenght_bit = 8;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
     furi_string_cat_printf(
         output,
         "%s - %dbit\r\n"

lib/subghz/protocols/keeloq.c

@@ -187,10 +187,15 @@ static bool subghz_protocol_keeloq_gen_data(
         if(keeloq_counter_mode == 0) {
             // Check for OFEX (overflow experimental) mode
             if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
-                if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+                // standart counter mode. PULL data from subghz_block_generic_global variables
-                    instance->generic.cnt = 0;
+                if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
-                } else {
+                    // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
-                    instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+                    if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) >
+                       0xFFFF) {
+                        instance->generic.cnt = 0;
+                    } else {
+                        instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+                    }
                 }
             } else {
                 if((instance->generic.cnt + 0x1) > 0xFFFF) {
@@ -1424,6 +1429,9 @@ void subghz_protocol_decoder_keeloq_get_string(void* context, FuriString* output
     uint32_t code_found_reverse_lo = code_found_reverse & 0x00000000ffffffff;
 
     if(strcmp(instance->manufacture_name, "BFT") == 0) {
+        subghz_block_generic_global.cnt_is_available = true;
+        subghz_block_generic_global.cnt_lenght_bit = 16;
+        subghz_block_generic_global.current_cnt = instance->generic.cnt;
         furi_string_cat_printf(
             output,
             "%s %dbit\r\n"
@@ -1459,6 +1467,9 @@ void subghz_protocol_decoder_keeloq_get_string(void* context, FuriString* output
             instance->generic.btn,
             instance->manufacture_name);
     } else {
+        subghz_block_generic_global.cnt_is_available = true;
+        subghz_block_generic_global.cnt_lenght_bit = 16;
+        subghz_block_generic_global.current_cnt = instance->generic.cnt;
         furi_string_cat_printf(
             output,
             "%s %dbit\r\n"

lib/subghz/protocols/kia.c

@@ -257,6 +257,9 @@ void subghz_protocol_decoder_kia_get_string(void* context, FuriString* output) {
     uint32_t code_found_lo = instance->generic.data & 0x00000000ffffffff;
 
     // use 'Cntr:' instead of 'Cnt:' to exclude this protocol counter from Counter edit
+    subghz_block_generic_global.cnt_lenght_bit = 16;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
     furi_string_cat_printf(
         output,
         "%s %dbit\r\n"

lib/subghz/protocols/kinggates_stylo_4k.c

@@ -157,10 +157,14 @@ static bool subghz_protocol_kinggates_stylo_4k_gen_data(
 
     // Check for OFEX (overflow experimental) mode
     if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
-        if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+        // standart counter mode. PULL data from subghz_block_generic_global variables
-            instance->generic.cnt = 0;
+        if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
-        } else {
+            // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
-            instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+            if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+                instance->generic.cnt = 0;
+            } else {
+                instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+            }
         }
     } else {
         if((instance->generic.cnt + 0x1) > 0xFFFF) {
@@ -580,6 +584,11 @@ void subghz_protocol_decoder_kinggates_stylo_4k_get_string(void* context, FuriSt
     SubGhzProtocolDecoderKingGates_stylo_4k* instance = context;
     subghz_protocol_kinggates_stylo_4k_remote_controller(&instance->generic, instance->keystore);
 
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.cnt_lenght_bit = 16;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
     furi_string_cat_printf(
         output,
         "%s\r\n"

lib/subghz/protocols/nice_flor_s.c

@@ -155,10 +155,14 @@ static void subghz_protocol_encoder_nice_flor_s_get_upload(
     if(nice_flors_counter_mode == 0) {
         // Check for OFEX (overflow experimental) mode
         if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
-            if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+            // standart counter mode. PULL data from subghz_block_generic_global variables
-                instance->generic.cnt = 0;
+            if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
-            } else {
+                // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
-                instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+                if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+                    instance->generic.cnt = 0;
+                } else {
+                    instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+                }
             }
         } else {
             if((instance->generic.cnt + 0x1) > 0xFFFF) {
@@ -910,6 +914,11 @@ void subghz_protocol_decoder_nice_flor_s_get_string(void* context, FuriString* o
     subghz_protocol_nice_flor_s_remote_controller(
         &instance->generic, instance->nice_flor_s_rainbow_table_file_name);
 
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.cnt_lenght_bit = 16;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
     if(instance->generic.data_count_bit == NICE_ONE_COUNT_BIT) {
         furi_string_cat_printf(
             output,

lib/subghz/protocols/phoenix_v2.c

@@ -254,10 +254,14 @@ static bool
     // Reconstruction of the data
     // Check for OFEX (overflow experimental) mode
     if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
-        if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+        // standart counter mode. PULL data from subghz_block_generic_global variables
-            instance->generic.cnt = 0;
+        if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
-        } else {
+            // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
-            instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+            if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+                instance->generic.cnt = 0;
+            } else {
+                instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+            }
         }
     } else {
         if((instance->generic.cnt + 0x1) > 0xFFFF) {
@@ -588,6 +592,12 @@ void subghz_protocol_decoder_phoenix_v2_get_string(void* context, FuriString* ou
     furi_assert(context);
     SubGhzProtocolDecoderPhoenix_V2* instance = context;
     subghz_protocol_phoenix_v2_check_remote_controller(&instance->generic);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.cnt_lenght_bit = 16;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
     furi_string_cat_printf(
         output,
         "V2 Phoenix %dbit\r\n"

lib/subghz/protocols/scher_khan.c

@@ -298,6 +298,10 @@ void subghz_protocol_decoder_scher_khan_get_string(void* context, FuriString* ou
         &instance->generic, &instance->protocol_name);
 
     // use 'Cntr:' instead of 'Cnt:' to exclude this protocol counter from Counter edit
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_lenght_bit = 16;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
     furi_string_cat_printf(
         output,
         "%s %dbit\r\n"

lib/subghz/protocols/secplus_v1.c

@@ -220,43 +220,19 @@ static bool subghz_protocol_secplus_v1_encode(SubGhzProtocolEncoderSecPlus_v1* i
     //increment the counter
     //rolling += 2; - old way
     // Experemental case - we dont know counter size exactly, so just will be think that it is in range of 0xE6000000 - 0xFFFFFFFF
-    // one case when we have mult = 0xFFFFFFFF  - its when we reset counter before applying new cnt value
+
-    // so at first step we reset cnt to 0 and now we sure here will be second step (set new cnt value);
-    // at second step check what user set for new Cnt (and correct it if cnt less than 0xE6000000 or more than 0xFFFFFFFF)
-    int32_t multicntr = (furi_hal_subghz_get_rolling_counter_mult() & 0xFFFFFFF);
-    // Adjust for negative multiplier
-    if(furi_hal_subghz_get_rolling_counter_mult() < 0) {
-        multicntr = furi_hal_subghz_get_rolling_counter_mult();
-    }
-    if(multicntr == 1) {
-        multicntr = 2; // to keep old behaviour when mult = 1
-    }
     // Check for OFEX (overflow experimental) mode
     if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
-        if((furi_hal_subghz_get_rolling_counter_mult() == (int32_t)0xFFFFFFF) & (rolling != 0)) {
+        // standart counter mode. PULL data from subghz_block_generic_global variables
-            rolling = 0;
+        if(!subghz_block_generic_global_counter_override_get(&rolling)) {
-        } else {
+            // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
-            // if cnt was reset to 0 on previous step and user want new Cnt then set it to 0xE6000000 or 0xFFFFFFFF or new user value
+            if((rolling + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFFFFFF) {
-            if(rolling == 0) {
+                rolling = 0xE6000000;
-                if((furi_hal_subghz_get_rolling_counter_mult()) < (int32_t)0x6000000) {
-                    rolling = 0xE6000000;
-                } else {
-                    if((furi_hal_subghz_get_rolling_counter_mult()) >= (int32_t)0xFFFFFFF) {
-                        rolling = 0xFFFFFFFF;
-                    } else {
-                        rolling = 0xE0000000;
-                        rolling += multicntr;
-                    }
-                }
             } else {
-                // if we have not special cases - so work as standart mode
+                rolling += furi_hal_subghz_get_rolling_counter_mult();
-                if((rolling + multicntr) > 0xFFFFFFFF) {
-                    rolling = 0xE6000000;
-                } else {
-                    rolling += multicntr;
-                }
             }
         }
+        if(rolling < 0xE6000000) rolling = 0xE6000000;
     } else {
         // OFEX (overflow experimental) mode
         if((rolling + 0x1) > 0xFFFFFFFF) {
@@ -605,6 +581,11 @@ void subghz_protocol_decoder_secplus_v1_get_string(void* context, FuriString* ou
     uint8_t id1 = (fixed / 9) % 3;
     uint16_t pin = 0;
 
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.cnt_lenght_bit = 32;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
     furi_string_cat_printf(
         output,
         "%s %db\r\n"

lib/subghz/protocols/secplus_v2.c

@@ -402,40 +402,19 @@ static void subghz_protocol_secplus_v2_encode(SubGhzProtocolEncoderSecPlus_v2* i
     uint8_t roll_2[9] = {0};
 
     // Experemental case - we dont know counter size exactly, so just will be think that it is in range of 0xE500000 - 0xFFFFFFF
-    // one case when we have mult = 0xFFFFFFFF  - its when we reset counter before applying new cnt value
+
-    // so at first step we reset cnt to 0 and now we sure here will be second step (set new cnt value);
-    // at second step check what user set for new Cnt (and correct it if cnt less than 0xE500000 or more than 0xFFFFFFF)
-    int32_t multicntr = (furi_hal_subghz_get_rolling_counter_mult() & 0xFFFFFFF);
-    // Adjust for negative multiplier
-    if(furi_hal_subghz_get_rolling_counter_mult() < 0) {
-        multicntr = furi_hal_subghz_get_rolling_counter_mult();
-    }
     // Check for OFEX (overflow experimental) mode
     if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
-        if((furi_hal_subghz_get_rolling_counter_mult() == (int32_t)0xFFFFFFF) &
+        // standart counter mode. PULL data from subghz_block_generic_global variables
-           (instance->generic.cnt != 0)) {
+        if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
-            instance->generic.cnt = 0;
+            // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
-        } else {
+            if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFFFFF) {
-            // if cnt was reset to 0 on previous step and user want new Cnt then set it to 0xE500000 or 0xFFFFFFF or new user value
+                instance->generic.cnt = 0xE500000;
-            if(instance->generic.cnt == 0) {
-                if(furi_hal_subghz_get_rolling_counter_mult() < (int32_t)0xE500000) {
-                    instance->generic.cnt = 0xE500000;
-                } else {
-                    if(furi_hal_subghz_get_rolling_counter_mult() >= (int32_t)0xFFFFFFF) {
-                        instance->generic.cnt = 0xFFFFFFF;
-                    } else {
-                        instance->generic.cnt += multicntr;
-                    }
-                }
             } else {
-                // if we have not special cases - so work as standart mode
+                instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
-                if((instance->generic.cnt + multicntr) > 0xFFFFFFF) {
-                    instance->generic.cnt = 0xE500000;
-                } else {
-                    instance->generic.cnt += multicntr;
-                }
             }
         }
+        if(instance->generic.cnt < 0xE500000) instance->generic.cnt = 0xE500000;
     } else {
         // OFEX (overflow experimental) mode
         if((instance->generic.cnt + 0x1) > 0xFFFFFFF) {
@@ -982,6 +961,11 @@ void subghz_protocol_decoder_secplus_v2_get_string(void* context, FuriString* ou
     subghz_protocol_secplus_v2_remote_controller(&instance->generic, instance->secplus_packet_1);
 
     // need to research or practice check how much bits in counter
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.cnt_lenght_bit = 28;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
     furi_string_cat_printf(
         output,
         "%s %db\r\n"

lib/subghz/protocols/somfy_keytis.c

@@ -132,10 +132,14 @@ static bool
 
     // Check for OFEX (overflow experimental) mode
     if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
-        if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+        // standart counter mode. PULL data from subghz_block_generic_global variables
-            instance->generic.cnt = 0;
+        if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
-        } else {
+            // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
-            instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+            if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+                instance->generic.cnt = 0;
+            } else {
+                instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+            }
         }
     } else {
         if((instance->generic.cnt + 0x1) > 0xFFFF) {
@@ -792,6 +796,11 @@ void subghz_protocol_decoder_somfy_keytis_get_string(void* context, FuriString*
 
     subghz_protocol_somfy_keytis_check_remote_controller(&instance->generic);
 
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.cnt_lenght_bit = 16;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
     furi_string_cat_printf(
         output,
         "%s %db\r\n"

lib/subghz/protocols/somfy_telis.c

@@ -126,10 +126,14 @@ static bool subghz_protocol_somfy_telis_gen_data(
 
     // Check for OFEX (overflow experimental) mode
     if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
-        if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+        // standart counter mode. PULL data from subghz_block_generic_global variables
-            instance->generic.cnt = 0;
+        if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
-        } else {
+            // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
-            instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+            if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+                instance->generic.cnt = 0;
+            } else {
+                instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+            }
         }
     } else {
         if((instance->generic.cnt + 0x1) > 0xFFFF) {
@@ -748,6 +752,12 @@ void subghz_protocol_decoder_somfy_telis_get_string(void* context, FuriString* o
     SubGhzProtocolDecoderSomfyTelis* instance = context;
 
     subghz_protocol_somfy_telis_check_remote_controller(&instance->generic);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.cnt_lenght_bit = 16;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
     furi_string_cat_printf(
         output,
         "%s %db\r\n"

lib/subghz/protocols/star_line.c

@@ -131,10 +131,14 @@ static bool
     subghz_protocol_star_line_gen_data(SubGhzProtocolEncoderStarLine* instance, uint8_t btn) {
     // Check for OFEX (overflow experimental) mode
     if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
-        if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+        // standart counter mode. PULL data from subghz_block_generic_global variables
-            instance->generic.cnt = 0;
+        if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
-        } else {
+            // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
-            instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+            if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+                instance->generic.cnt = 0;
+            } else {
+                instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+            }
         }
     } else {
         if((instance->generic.cnt + 0x1) > 0xFFFF) {
@@ -719,6 +723,11 @@ void subghz_protocol_decoder_star_line_get_string(void* context, FuriString* out
     uint32_t code_found_reverse_hi = code_found_reverse >> 32;
     uint32_t code_found_reverse_lo = code_found_reverse & 0x00000000ffffffff;
 
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.cnt_lenght_bit = 16;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
     furi_string_cat_printf(
         output,
         "%s %dbit\r\n"

targets/f7/api_symbols.csv

@@ -1,5 +1,5 @@
 entry,status,name,type,params
-Version,+,87.1,,
+Version,+,87.2,,
 Header,+,applications/drivers/subghz/cc1101_ext/cc1101_ext_interconnect.h,,
 Header,+,applications/services/bt/bt_service/bt.h,,
 Header,+,applications/services/bt/bt_service/bt_keys_storage.h,,
@@ -3564,6 +3564,9 @@ Function,-,strxfrm_l,size_t,"char*, const char*, size_t, locale_t"
 Function,+,subghz_block_generic_deserialize,SubGhzProtocolStatus,"SubGhzBlockGeneric*, FlipperFormat*"
 Function,+,subghz_block_generic_deserialize_check_count_bit,SubGhzProtocolStatus,"SubGhzBlockGeneric*, FlipperFormat*, uint16_t"
 Function,+,subghz_block_generic_get_preset_name,void,"const char*, FuriString*"
+Function,+,subghz_block_generic_global_counter_override_get,_Bool,uint32_t*
+Function,+,subghz_block_generic_global_counter_override_set,void,uint32_t
+Function,+,subghz_block_generic_global_reset,void,void*
 Function,+,subghz_block_generic_serialize,SubGhzProtocolStatus,"SubGhzBlockGeneric*, FlipperFormat*, SubGhzRadioPreset*"
 Function,+,subghz_custom_btn_get,uint8_t,
 Function,+,subghz_custom_btn_get_original,uint8_t,
@@ -4273,6 +4276,7 @@ Variable,+,sequence_single_vibro,const NotificationSequence,
 Variable,+,sequence_solid_yellow,const NotificationSequence,
 Variable,+,sequence_success,const NotificationSequence,
 Variable,+,simple_array_config_uint8_t,const SimpleArrayConfig,
+Variable,+,subghz_block_generic_global,SubGhzBlockGenericGlobal,
 Variable,-,subghz_device_cc1101_int,const SubGhzDevice,
 Variable,+,subghz_device_cc1101_preset_2fsk_dev2_38khz_async_regs,const uint8_t[],
 Variable,+,subghz_device_cc1101_preset_2fsk_dev47_6khz_async_regs,const uint8_t[],