Update subghz

lib/subghz/SConscript

@@ -11,6 +11,7 @@ env.Append(
         File("subghz_tx_rx_worker.h"),
         File("transmitter.h"),
         File("registry.h"),
+        File("protocols/protocol_items.h"),
         File("protocols/raw.h"),
         File("blocks/const.h"),
         File("blocks/decoder.h"),

lib/subghz/blocks/encoder.c

@@ -55,4 +55,4 @@ size_t subghz_protocol_blocks_get_upload_from_bit_array(
     upload[size_upload++] = level_duration_make(
         subghz_protocol_blocks_get_bit_array(data_array, index_bit - 1), duration);
     return size_upload;
-}
+}

lib/subghz/blocks/generic.c

@@ -100,7 +100,7 @@ bool subghz_block_generic_deserialize(SubGhzBlockGeneric* instance, FlipperForma
             FURI_LOG_E(TAG, "Missing Bit");
             break;
         }
-        instance->data_count_bit = (uint8_t)temp_data;
+        instance->data_count_bit = (uint16_t)temp_data;
 
         uint8_t key_data[sizeof(uint64_t)] = {0};
         if(!flipper_format_read_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {

lib/subghz/blocks/generic.h

@@ -20,7 +20,7 @@ struct SubGhzBlockGeneric {
     uint64_t data;
     uint64_t data_2;
     uint32_t serial;
-    uint8_t data_count_bit;
+    uint16_t data_count_bit;
     uint8_t btn;
     uint32_t cnt;
     uint8_t cnt_2;

lib/subghz/protocols/bin_raw.c

@@ -111,7 +111,7 @@ const SubGhzProtocolEncoder subghz_protocol_bin_raw_encoder = {
 
 const SubGhzProtocol subghz_protocol_bin_raw = {
     .name = SUBGHZ_PROTOCOL_BIN_RAW_NAME,
-    .type = SubGhzProtocolTypeStatic,
+    .type = SubGhzProtocolTypeBinRAW,
 #ifdef BIN_RAW_DEBUG
     .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_315 | SubGhzProtocolFlag_868 |
             SubGhzProtocolFlag_AM | SubGhzProtocolFlag_FM | SubGhzProtocolFlag_Decodable |
@@ -1117,4 +1117,4 @@ void subghz_protocol_decoder_bin_raw_get_string(void* context, FuriString* outpu
     }
 
     furi_string_cat_printf(output, "\r\nTe:%luus\r\n", instance->te);
-}
+}

lib/subghz/protocols/kinggates_stylo_4k.c

@@ -23,7 +23,6 @@ struct SubGhzProtocolDecoderKingGates_stylo_4k {
     SubGhzBlockDecoder decoder;
     SubGhzBlockGeneric generic;
 
-    uint64_t data;
     uint16_t header_count;
     SubGhzKeystore* keystore;
 };
@@ -33,6 +32,7 @@ struct SubGhzProtocolEncoderKingGates_stylo_4k {
 
     SubGhzProtocolBlockEncoder encoder;
     SubGhzBlockGeneric generic;
+    SubGhzKeystore* keystore;
 };
 
 typedef enum {
@@ -57,23 +57,268 @@ const SubGhzProtocolDecoder subghz_protocol_kinggates_stylo_4k_decoder = {
 };
 
 const SubGhzProtocolEncoder subghz_protocol_kinggates_stylo_4k_encoder = {
-    .alloc = NULL,
-    .free = NULL,
+    .alloc = subghz_protocol_encoder_kinggates_stylo_4k_alloc,
+    .free = subghz_protocol_encoder_kinggates_stylo_4k_free,
 
-    .deserialize = NULL,
-    .stop = NULL,
-    .yield = NULL,
+    .deserialize = subghz_protocol_encoder_kinggates_stylo_4k_deserialize,
+    .stop = subghz_protocol_encoder_kinggates_stylo_4k_stop,
+    .yield = subghz_protocol_encoder_kinggates_stylo_4k_yield,
 };
 
 const SubGhzProtocol subghz_protocol_kinggates_stylo_4k = {
     .name = SUBGHZ_PROTOCOL_KINGGATES_STYLO_4K_NAME,
     .type = SubGhzProtocolTypeDynamic,
-    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
 
     .decoder = &subghz_protocol_kinggates_stylo_4k_decoder,
     .encoder = &subghz_protocol_kinggates_stylo_4k_encoder,
 };
 
+//
+// Encoder
+//
+
+// Pre define function
+static void subghz_protocol_kinggates_stylo_4k_remote_controller(
+    SubGhzBlockGeneric* instance,
+    SubGhzKeystore* keystore);
+
+void* subghz_protocol_encoder_kinggates_stylo_4k_alloc(SubGhzEnvironment* environment) {
+    SubGhzProtocolEncoderKingGates_stylo_4k* instance =
+        malloc(sizeof(SubGhzProtocolEncoderKingGates_stylo_4k));
+
+    instance->base.protocol = &subghz_protocol_kinggates_stylo_4k;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    instance->keystore = subghz_environment_get_keystore(environment);
+
+    instance->encoder.repeat = 10;
+    instance->encoder.size_upload = 512;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+
+    return instance;
+}
+
+void subghz_protocol_encoder_kinggates_stylo_4k_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderKingGates_stylo_4k* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+void subghz_protocol_encoder_kinggates_stylo_4k_stop(void* context) {
+    SubGhzProtocolEncoderKingGates_stylo_4k* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_kinggates_stylo_4k_yield(void* context) {
+    SubGhzProtocolEncoderKingGates_stylo_4k* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+/** 
+ * Key generation from simple data
+ * @param instance Pointer to a SubGhzProtocolEncoderKingGates_stylo_4k* instance
+ * @param btn Button number, 4 bit
+ */
+static bool subghz_protocol_kinggates_stylo_4k_gen_data(
+    SubGhzProtocolEncoderKingGates_stylo_4k* instance,
+    uint8_t btn) {
+    UNUSED(btn);
+    uint32_t hop = subghz_protocol_blocks_reverse_key(instance->generic.data_2 >> 4, 32);
+    uint64_t fix = subghz_protocol_blocks_reverse_key(instance->generic.data, 53);
+    int res = 0;
+    uint32_t decrypt = 0;
+
+    for
+        M_EACH(manufacture_code, *subghz_keystore_get_data(instance->keystore), SubGhzKeyArray_t) {
+            res = strcmp(furi_string_get_cstr(manufacture_code->name), "Kingates_Stylo4k");
+            if(res == 0) {
+                //Simple Learning
+                decrypt = subghz_protocol_keeloq_common_decrypt(hop, manufacture_code->key);
+                break;
+            }
+        }
+    instance->generic.cnt = decrypt & 0xFFFF;
+
+    if(instance->generic.cnt < 0xFFFF) {
+        instance->generic.cnt++;
+    } else if(instance->generic.cnt >= 0xFFFF) {
+        instance->generic.cnt = 0;
+    }
+
+    instance->generic.btn = (fix >> 17) & 0x0F;
+    instance->generic.serial = ((fix >> 5) & 0xFFFF0000) | (fix & 0xFFFF);
+
+    uint32_t data = (decrypt & 0xFFFF0000) | instance->generic.cnt;
+
+    uint64_t encrypt = 0;
+    for
+        M_EACH(manufacture_code, *subghz_keystore_get_data(instance->keystore), SubGhzKeyArray_t) {
+            res = strcmp(furi_string_get_cstr(manufacture_code->name), "Kingates_Stylo4k");
+            if(res == 0) {
+                //Simple Learning
+                encrypt = subghz_protocol_keeloq_common_encrypt(data, manufacture_code->key);
+                encrypt = subghz_protocol_blocks_reverse_key(encrypt, 32);
+                instance->generic.data_2 = encrypt << 4;
+                return true;
+            }
+        }
+
+    return false;
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderKingGates_stylo_4k instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_kinggates_stylo_4k_get_upload(
+    SubGhzProtocolEncoderKingGates_stylo_4k* instance,
+    uint8_t btn) {
+    furi_assert(instance);
+
+    // Gen new key
+    if(subghz_protocol_kinggates_stylo_4k_gen_data(instance, btn)) {
+        //ToDo if you need to add a callback to automatically update the data on the display
+    } else {
+        return false;
+    }
+
+    size_t index = 0;
+
+    // Start
+    instance->encoder.upload[index++] = level_duration_make(false, (uint32_t)9500);
+
+    // Send header
+    for(uint8_t i = 12; i > 0; i--) {
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_short);
+        instance->encoder.upload[index++] = level_duration_make(
+            false, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_short);
+    }
+
+    // After header
+    instance->encoder.upload[index - 1].duration =
+        (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_long * 2;
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_short * 2);
+
+    // Send key fix
+    for(uint8_t i = 53; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] = level_duration_make(
+                false, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_short);
+            instance->encoder.upload[index++] = level_duration_make(
+                true, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_long);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] = level_duration_make(
+                false, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_long);
+            instance->encoder.upload[index++] = level_duration_make(
+                true, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_short);
+        }
+    }
+
+    // Send key hop
+    for(uint8_t i = 36; i > 0; i--) {
+        if(bit_read(instance->generic.data_2, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] = level_duration_make(
+                false, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_short);
+            instance->encoder.upload[index++] = level_duration_make(
+                true, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_long);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] = level_duration_make(
+                false, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_long);
+            instance->encoder.upload[index++] = level_duration_make(
+                true, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_short);
+        }
+    }
+
+    // Set upload size after generating upload, fix it later
+
+    instance->encoder.size_upload = index;
+
+    return true;
+}
+
+bool subghz_protocol_encoder_kinggates_stylo_4k_deserialize(
+    void* context,
+    FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderKingGates_stylo_4k* instance = context;
+    bool res = false;
+    do {
+        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+            FURI_LOG_E(TAG, "Deserialize error");
+            break;
+        }
+
+        subghz_protocol_kinggates_stylo_4k_remote_controller(
+            &instance->generic, instance->keystore);
+
+        //optional parameter parameter
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        if(!flipper_format_read_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Missing Data");
+            break;
+        }
+
+        for(uint8_t i = 0; i < sizeof(uint64_t); i++) {
+            instance->generic.data_2 = instance->generic.data_2 << 8 | key_data[i];
+        }
+
+        subghz_protocol_encoder_kinggates_stylo_4k_get_upload(instance, instance->generic.btn);
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data_2 >> i * 8) & 0xFF;
+        }
+        if(!flipper_format_update_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to add Key");
+            break;
+        }
+
+        instance->encoder.is_running = true;
+
+        res = true;
+    } while(false);
+
+    return res;
+}
+
+//
+// Decoder
+//
 void* subghz_protocol_decoder_kinggates_stylo_4k_alloc(SubGhzEnvironment* environment) {
     SubGhzProtocolDecoderKingGates_stylo_4k* instance =
         malloc(sizeof(SubGhzProtocolDecoderKingGates_stylo_4k));
@@ -130,7 +375,7 @@ void subghz_protocol_decoder_kinggates_stylo_4k_feed(void* context, bool level,
                subghz_protocol_kinggates_stylo_4k_const.te_delta * 2) {
             instance->decoder.parser_step = KingGates_stylo_4kDecoderStepSaveDuration;
             instance->decoder.decode_data = 0;
-            instance->data = 0;
+            instance->generic.data_2 = 0;
             instance->decoder.decode_count_bit = 0;
             instance->header_count = 0;
         }
@@ -140,8 +385,8 @@ void subghz_protocol_decoder_kinggates_stylo_4k_feed(void* context, bool level,
             if(duration >= ((uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_long * 3)) {
                 if(instance->decoder.decode_count_bit ==
                    subghz_protocol_kinggates_stylo_4k_const.min_count_bit_for_found) {
-                    instance->generic.data = instance->data;
-                    instance->data = instance->decoder.decode_data;
+                    instance->generic.data = instance->generic.data_2;
+                    instance->generic.data_2 = instance->decoder.decode_data;
                     instance->generic.data_count_bit = instance->decoder.decode_count_bit;
 
                     if(instance->base.callback)
@@ -150,7 +395,7 @@ void subghz_protocol_decoder_kinggates_stylo_4k_feed(void* context, bool level,
 
                 instance->decoder.parser_step = KingGates_stylo_4kDecoderStepReset;
                 instance->decoder.decode_data = 0;
-                instance->data = 0;
+                instance->generic.data_2 = 0;
                 instance->decoder.decode_count_bit = 0;
                 instance->header_count = 0;
                 break;
@@ -185,7 +430,7 @@ void subghz_protocol_decoder_kinggates_stylo_4k_feed(void* context, bool level,
                 instance->header_count = 0;
             }
             if(instance->decoder.decode_count_bit == 53) {
-                instance->data = instance->decoder.decode_data;
+                instance->generic.data_2 = instance->decoder.decode_data;
                 instance->decoder.decode_data = 0;
             }
         } else {
@@ -199,11 +444,11 @@ void subghz_protocol_decoder_kinggates_stylo_4k_feed(void* context, bool level,
 /** 
  * Analysis of received data
  * @param instance Pointer to a SubGhzBlockGeneric* instance
- * @param file_name Full path to rainbow table the file
+ * @param data Input encrypted data
+ * @param keystore Pointer to a SubGhzKeystore* instance
  */
 static void subghz_protocol_kinggates_stylo_4k_remote_controller(
     SubGhzBlockGeneric* instance,
-    uint64_t data,
     SubGhzKeystore* keystore) {
     /**
  *  9500us   12*(400/400)  2200/800|1-bit|0-bit|
@@ -226,7 +471,7 @@ static void subghz_protocol_kinggates_stylo_4k_remote_controller(
  * 
 */
 
-    uint32_t hop = subghz_protocol_blocks_reverse_key(data >> 4, 32);
+    uint32_t hop = subghz_protocol_blocks_reverse_key(instance->data_2 >> 4, 32);
     uint64_t fix = subghz_protocol_blocks_reverse_key(instance->data, 53);
     bool ret = false;
     uint32_t decrypt = 0;
@@ -270,7 +515,7 @@ bool subghz_protocol_decoder_kinggates_stylo_4k_serialize(
 
     uint8_t key_data[sizeof(uint64_t)] = {0};
     for(size_t i = 0; i < sizeof(uint64_t); i++) {
-        key_data[sizeof(uint64_t) - i - 1] = (instance->data >> (i * 8)) & 0xFF;
+        key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data_2 >> (i * 8)) & 0xFF;
     }
 
     if(res && !flipper_format_write_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
@@ -306,8 +551,9 @@ bool subghz_protocol_decoder_kinggates_stylo_4k_deserialize(
             FURI_LOG_E(TAG, "Missing Data");
             break;
         }
+
         for(uint8_t i = 0; i < sizeof(uint64_t); i++) {
-            instance->data = instance->data << 8 | key_data[i];
+            instance->generic.data_2 = instance->generic.data_2 << 8 | key_data[i];
         }
         ret = true;
     } while(false);
@@ -317,8 +563,7 @@ bool subghz_protocol_decoder_kinggates_stylo_4k_deserialize(
 void subghz_protocol_decoder_kinggates_stylo_4k_get_string(void* context, FuriString* output) {
     furi_assert(context);
     SubGhzProtocolDecoderKingGates_stylo_4k* instance = context;
-    subghz_protocol_kinggates_stylo_4k_remote_controller(
-        &instance->generic, instance->data, instance->keystore);
+    subghz_protocol_kinggates_stylo_4k_remote_controller(&instance->generic, instance->keystore);
 
     furi_string_cat_printf(
         output,
@@ -328,9 +573,9 @@ void subghz_protocol_decoder_kinggates_stylo_4k_get_string(void* context, FuriSt
         "Cnt:0x%04lX\r\n",
         instance->generic.protocol_name,
         instance->generic.data,
-        instance->data,
+        instance->generic.data_2,
         instance->generic.data_count_bit,
         instance->generic.serial,
         instance->generic.btn,
         instance->generic.cnt);
-}
+}

lib/subghz/protocols/kinggates_stylo_4k.h

@@ -10,6 +10,42 @@ extern const SubGhzProtocolDecoder subghz_protocol_kinggates_stylo_4k_decoder;
 extern const SubGhzProtocolEncoder subghz_protocol_kinggates_stylo_4k_encoder;
 extern const SubGhzProtocol subghz_protocol_kinggates_stylo_4k;
 
+/**
+ * Allocate SubGhzProtocolEncoderKingGates_stylo_4k.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderKingGates_stylo_4k* pointer to a SubGhzProtocolEncoderKingGates_stylo_4k instance
+ */
+void* subghz_protocol_encoder_kinggates_stylo_4k_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderKingGates_stylo_4k.
+ * @param context Pointer to a SubGhzProtocolEncoderKingGates_stylo_4k instance
+ */
+void subghz_protocol_encoder_kinggates_stylo_4k_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderKingGates_stylo_4k instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return true On success
+ */
+bool subghz_protocol_encoder_kinggates_stylo_4k_deserialize(
+    void* context,
+    FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderKingGates_stylo_4k instance
+ */
+void subghz_protocol_encoder_kinggates_stylo_4k_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderKingGates_stylo_4k instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_kinggates_stylo_4k_yield(void* context);
+
 /**
  * Allocate SubGhzProtocolDecoderKingGates_stylo_4k.
  * @param environment Pointer to a SubGhzEnvironment instance

lib/subghz/protocols/protocol_items.c

@@ -36,13 +36,13 @@ const SubGhzProtocol* subghz_protocol_registry_items[] = {
     &subghz_protocol_intertechno_v3,
     &subghz_protocol_clemsa,
     &subghz_protocol_ansonic,
-    &subghz_protocol_pocsag,
     &subghz_protocol_smc5326,
     &subghz_protocol_holtek_th12x,
     &subghz_protocol_linear_delta3,
     &subghz_protocol_dooya,
     &subghz_protocol_alutech_at_4n,
     &subghz_protocol_kinggates_stylo_4k,
+    &subghz_protocol_bin_raw,
 };
 
 const SubGhzProtocolRegistry subghz_protocol_registry = {

lib/subghz/protocols/protocol_items.h

@@ -37,12 +37,12 @@
 #include "intertechno_v3.h"
 #include "clemsa.h"
 #include "ansonic.h"
-#include "pocsag.h"
 #include "smc5326.h"
 #include "holtek_ht12x.h"
 #include "dooya.h"
 #include "alutech_at_4n.h"
 #include "kinggates_stylo_4k.h"
+#include "bin_raw.h"
 
 #ifdef __cplusplus
 extern "C" {

lib/subghz/protocols/raw.c

@@ -8,16 +8,11 @@
 #include "../blocks/generic.h"
 #include "../blocks/math.h"
 
-#include <furi.h>
 #include <flipper_format/flipper_format_i.h>
 #include <lib/toolbox/stream/stream.h>
-#include <stm32wbxx_ll_rtc.h>
 
 #define TAG "SubGhzProtocolRAW"
 #define SUBGHZ_DOWNLOAD_MAX_SIZE 512
-#define SUBGHZ_AUTO_DETECT_DOWNLOAD_MAX_SIZE 2048
-#define SUBGHZ_AUTO_DETECT_RAW_THRESHOLD -72.0f
-#define SUBGHZ_AUTO_DETECT_RAW_POSTROLL_FRAMES 40
 
 static const SubGhzBlockConst subghz_protocol_raw_const = {
     .te_short = 50,
@@ -29,8 +24,6 @@ static const SubGhzBlockConst subghz_protocol_raw_const = {
 struct SubGhzProtocolDecoderRAW {
     SubGhzProtocolDecoderBase base;
 
-    SubGhzBlockDecoder decoder;
-
     int32_t* upload_raw;
     uint16_t ind_write;
     Storage* storage;
@@ -39,10 +32,6 @@ struct SubGhzProtocolDecoderRAW {
     FuriString* file_name;
     size_t sample_write;
     bool last_level;
-    bool auto_mode;
-    bool has_rssi_above_threshold;
-    int rssi_threshold;
-    uint8_t postroll_frames;
     bool pause;
 };
 
@@ -67,8 +56,8 @@ const SubGhzProtocolDecoder subghz_protocol_raw_decoder = {
     .feed = subghz_protocol_decoder_raw_feed,
     .reset = subghz_protocol_decoder_raw_reset,
 
-    .get_hash_data = subghz_protocol_decoder_raw_get_hash_data,
-    .serialize = subghz_protocol_decoder_raw_serialize,
+    .get_hash_data = NULL,
+    .serialize = NULL,
     .deserialize = subghz_protocol_decoder_raw_deserialize,
     .get_string = subghz_protocol_decoder_raw_get_string,
 };
@@ -213,36 +202,6 @@ void subghz_protocol_raw_save_to_file_stop(SubGhzProtocolDecoderRAW* instance) {
     instance->file_is_open = RAWFileIsOpenClose;
 }
 
-void subghz_protocol_decoder_raw_set_rssi_threshold(void* context, int rssi_threshold) {
-    furi_assert(context);
-    SubGhzProtocolDecoderRAW* instance = context;
-
-    FURI_LOG_D(TAG, "RSSI set: (%d)", rssi_threshold);
-
-    instance->rssi_threshold = rssi_threshold;
-
-    subghz_protocol_decoder_raw_reset(context);
-}
-
-void subghz_protocol_decoder_raw_set_auto_mode(void* context, bool auto_mode) {
-    furi_assert(context);
-    SubGhzProtocolDecoderRAW* instance = context;
-    instance->auto_mode = auto_mode;
-
-    if(auto_mode) {
-        if(instance->upload_raw == NULL) {
-            instance->upload_raw = malloc(SUBGHZ_AUTO_DETECT_DOWNLOAD_MAX_SIZE * sizeof(int32_t));
-        }
-    } else {
-        if(instance->upload_raw != NULL) {
-            free(instance->upload_raw);
-            instance->upload_raw = NULL;
-        }
-    }
-
-    subghz_protocol_decoder_raw_reset(context);
-}
-
 void subghz_protocol_raw_save_to_file_pause(SubGhzProtocolDecoderRAW* instance, bool pause) {
     furi_assert(instance);
 
@@ -263,8 +222,6 @@ void* subghz_protocol_decoder_raw_alloc(SubGhzEnvironment* environment) {
     instance->ind_write = 0;
     instance->last_level = false;
     instance->file_is_open = RAWFileIsOpenClose;
-    instance->postroll_frames = 0;
-    instance->rssi_threshold = SUBGHZ_AUTO_DETECT_RAW_THRESHOLD;
     instance->file_name = furi_string_alloc();
 
     return instance;
@@ -274,10 +231,6 @@ void subghz_protocol_decoder_raw_free(void* context) {
     furi_assert(context);
     SubGhzProtocolDecoderRAW* instance = context;
     furi_string_free(instance->file_name);
-    if(instance->upload_raw != NULL) {
-        free(instance->upload_raw);
-        instance->upload_raw = NULL;
-    }
     free(instance);
 }
 
@@ -285,66 +238,23 @@ void subghz_protocol_decoder_raw_reset(void* context) {
     furi_assert(context);
     SubGhzProtocolDecoderRAW* instance = context;
     instance->ind_write = 0;
-    instance->has_rssi_above_threshold = false;
     instance->last_level = false;
-    instance->postroll_frames = 0;
-}
-
-bool subghz_protocol_decoder_raw_write_data(void* context, bool level, uint32_t duration) {
-    furi_assert(context);
-    SubGhzProtocolDecoderRAW* instance = context;
-
-    bool wrote_data = false;
-
-    if(instance->last_level != level) {
-        instance->last_level = (level ? true : false);
-        instance->upload_raw[instance->ind_write++] = (level ? duration : -duration);
-        subghz_protocol_blocks_add_bit(&instance->decoder, (level) ? 1 : 0);
-        wrote_data = true;
-    }
-
-    if(instance->ind_write == SUBGHZ_AUTO_DETECT_DOWNLOAD_MAX_SIZE) {
-        if(instance->base.callback)
-            instance->base.callback(&instance->base, instance->base.context);
-
-        return false;
-    }
-
-    return wrote_data;
 }
 
 void subghz_protocol_decoder_raw_feed(void* context, bool level, uint32_t duration) {
     furi_assert(context);
     SubGhzProtocolDecoderRAW* instance = context;
 
-    if(instance->upload_raw != NULL && !instance->pause &&
-       duration > subghz_protocol_raw_const.te_short) {
-        if(instance->auto_mode) {
-            float rssi = furi_hal_subghz_get_rssi();
-
-            if(rssi >= instance->rssi_threshold) {
-                subghz_protocol_decoder_raw_write_data(context, level, duration);
-                instance->has_rssi_above_threshold = true;
-                instance->postroll_frames = 0;
-            } else if(instance->has_rssi_above_threshold) {
-                subghz_protocol_decoder_raw_write_data(instance, level, duration);
-                instance->postroll_frames++;
-
-                if(instance->postroll_frames >= SUBGHZ_AUTO_DETECT_RAW_POSTROLL_FRAMES) {
-                    if(instance->base.callback)
-                        instance->base.callback(&instance->base, instance->base.context);
-                }
-            }
-        } else {
+    if(!instance->pause && (instance->upload_raw != NULL)) {
+        if(duration > subghz_protocol_raw_const.te_short) {
             if(instance->last_level != level) {
                 instance->last_level = (level ? true : false);
                 instance->upload_raw[instance->ind_write++] = (level ? duration : -duration);
-                subghz_protocol_blocks_add_bit(&instance->decoder, (level) ? 1 : 0);
             }
+        }
 
-            if(instance->ind_write == SUBGHZ_DOWNLOAD_MAX_SIZE) {
-                subghz_protocol_raw_save_to_file_write(instance);
-            }
+        if(instance->ind_write == SUBGHZ_DOWNLOAD_MAX_SIZE) {
+            subghz_protocol_raw_save_to_file_write(instance);
         }
     }
 }
@@ -357,13 +267,6 @@ bool subghz_protocol_decoder_raw_deserialize(void* context, FlipperFormat* flipp
     return true;
 }
 
-uint8_t subghz_protocol_decoder_raw_get_hash_data(void* context) {
-    furi_assert(context);
-    SubGhzProtocolDecoderRAW* instance = context;
-    return subghz_protocol_blocks_get_hash_data(
-        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
-}
-
 void subghz_protocol_decoder_raw_get_string(void* context, FuriString* output) {
     furi_assert(context);
     //SubGhzProtocolDecoderRAW* instance = context;
@@ -382,13 +285,6 @@ void* subghz_protocol_encoder_raw_alloc(SubGhzEnvironment* environment) {
     return instance;
 }
 
-int subghz_protocol_encoder_get_rssi_threshold(void* context) {
-    furi_assert(context);
-    SubGhzProtocolDecoderRAW* instance = context;
-
-    return instance->rssi_threshold;
-}
-
 void subghz_protocol_encoder_raw_stop(void* context) {
     SubGhzProtocolEncoderRAW* instance = context;
     instance->is_running = false;
@@ -446,70 +342,6 @@ void subghz_protocol_raw_gen_fff_data(FlipperFormat* flipper_format, const char*
     } while(false);
 }
 
-bool subghz_protocol_decoder_raw_serialize(
-    void* context,
-    FlipperFormat* flipper_format,
-    SubGhzRadioPreset* preset) {
-    furi_assert(context);
-    SubGhzProtocolDecoderRAW* instance = context;
-    if(instance->auto_mode) {
-        furi_assert(instance);
-        bool res = false;
-        FuriString* temp_str;
-        temp_str = furi_string_alloc();
-
-        do {
-            stream_clean(flipper_format_get_raw_stream(flipper_format));
-            if(!flipper_format_write_header_cstr(
-                   flipper_format, SUBGHZ_RAW_FILE_TYPE, SUBGHZ_RAW_FILE_VERSION)) {
-                FURI_LOG_E(TAG, "Unable to add header");
-                break;
-            }
-
-            if(!flipper_format_write_uint32(flipper_format, "Frequency", &preset->frequency, 1)) {
-                FURI_LOG_E(TAG, "Unable to add Frequency");
-                break;
-            }
-            subghz_block_generic_get_preset_name(furi_string_get_cstr(preset->name), temp_str);
-            if(!flipper_format_write_string_cstr(
-                   flipper_format, "Preset", furi_string_get_cstr(temp_str))) {
-                FURI_LOG_E(TAG, "Unable to add Preset");
-                break;
-            }
-            if(!strcmp(furi_string_get_cstr(temp_str), "FuriHalSubGhzPresetCustom")) {
-                if(!flipper_format_write_string_cstr(
-                       flipper_format, "Custom_preset_module", "CC1101")) {
-                    FURI_LOG_E(TAG, "Unable to add Custom_preset_module");
-                    break;
-                }
-                if(!flipper_format_write_hex(
-                       flipper_format, "Custom_preset_data", preset->data, preset->data_size)) {
-                    FURI_LOG_E(TAG, "Unable to add Custom_preset_data");
-                    break;
-                }
-            }
-            if(!flipper_format_write_string_cstr(
-                   flipper_format, "Protocol", instance->base.protocol->name)) {
-                FURI_LOG_E(TAG, "Unable to add Protocol");
-                break;
-            }
-
-            if(!flipper_format_write_int32(
-                   flipper_format, "RAW_Data", instance->upload_raw, instance->ind_write)) {
-                FURI_LOG_E(TAG, "Unable to add Raw Data");
-                break;
-            } else {
-                instance->ind_write = 0;
-            }
-            res = true;
-        } while(false);
-        furi_string_free(temp_str);
-        return res;
-    } else {
-        return false;
-    }
-}
-
 bool subghz_protocol_encoder_raw_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderRAW* instance = context;

lib/subghz/protocols/raw.h

@@ -2,8 +2,6 @@
 
 #include "base.h"
 
-#include <furi_hal.h>
-
 #define SUBGHZ_PROTOCOL_RAW_NAME "RAW"
 
 #ifdef __cplusplus
@@ -31,27 +29,6 @@ bool subghz_protocol_raw_save_to_file_init(
     const char* dev_name,
     SubGhzRadioPreset* preset);
 
-/**
- * Set SubGhzProtocolDecoderRAW to auto mode, which allows subghz_scene_receiver to capture RAW.
- * @param context Pointer to a SubGhzProtocolDecoderRAW instance
- * @param auto_mode Whether or not to enable auto mode
- */
-void subghz_protocol_decoder_raw_set_auto_mode(void* context, bool auto_mode);
-
-/**
- * Set RSSI threshold ("sensitivity" level).
- * @param context Pointer to a SubGhzProtocolDecoderRAW instance
- * @param rssi_threshold The desired RSSI threshold
- */
-void subghz_protocol_decoder_raw_set_rssi_threshold(void* context, int rssi_threshold);
-
-/**
- * Get RSSI threshold ("sensitivity" level).
- * @param context Pointer to a SubGhzProtocolDecoderRAW instance
- * @return rssi threshold in db
- */
-int subghz_protocol_encoder_get_rssi_threshold(void* context);
-
 /**
  * Stop writing file to flash
  * @param instance Pointer to a SubGhzProtocolDecoderRAW instance
@@ -84,15 +61,6 @@ void subghz_protocol_decoder_raw_free(void* context);
  */
 void subghz_protocol_decoder_raw_reset(void* context);
 
-/**
- * Write raw data to the instance's internal buffer.
- * @param context Pointer to a SubGhzProtocolDecoderRAW instance
- * @param level Signal level true-high false-low
- * @param duration Duration of this level in, us
- * @return whether or not data was written
- */
-bool subghz_protocol_decoder_raw_write_data(void* context, bool level, uint32_t duration);
-
 /**
  * Parse a raw sequence of levels and durations received from the air.
  * @param context Pointer to a SubGhzProtocolDecoderRAW instance
@@ -103,19 +71,12 @@ void subghz_protocol_decoder_raw_feed(void* context, bool level, uint32_t durati
 
 /**
  * Deserialize data SubGhzProtocolDecoderRAW.
-  * @param context Pointer to a SubGhzProtocolDecoderRAW instance
-   * @param flipper_format Pointer to a FlipperFormat instance
+ * @param context Pointer to a SubGhzProtocolDecoderRAW instance
+ * @param flipper_format Pointer to a FlipperFormat instance
  * @return true On success
  */
 bool subghz_protocol_decoder_raw_deserialize(void* context, FlipperFormat* flipper_format);
 
-/**
- * Getting the hash sum of the last randomly received parcel.
- * @param context Pointer to a SubGhzProtocolDecoderRAW instance
- * @return hash Hash sum
- */
-uint8_t subghz_protocol_decoder_raw_get_hash_data(void* context);
-
 /**
  * Getting a textual representation of the received data.
  * @param context Pointer to a SubGhzProtocolDecoderRAW instance
@@ -167,19 +128,6 @@ void subghz_protocol_raw_file_encoder_worker_set_callback_end(
  */
 void subghz_protocol_raw_gen_fff_data(FlipperFormat* flipper_format, const char* file_path);
 
-/**
- * Serialize data SubGhzProtocolDecoderRAW.
- * @param context Pointer to a SubGhzProtocolDecoderRAW instance
- * @param flipper_format Pointer to a FlipperFormat instance
- * @param frequency The frequency at which the signal was received, Hz
- * @param preset The modulation on which the signal was received, FuriHalSubGhzPreset
- * @return true On success
- */
-bool subghz_protocol_decoder_raw_serialize(
-    void* context,
-    FlipperFormat* flipper_format,
-    SubGhzRadioPreset* preset);
-
 /**
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderRAW instance
@@ -191,7 +139,7 @@ bool subghz_protocol_encoder_raw_deserialize(void* context, FlipperFormat* flipp
 /**
  * Getting the level and duration of the upload to be loaded into DMA.
  * @param context Pointer to a SubGhzProtocolEncoderRAW instance
- * @return LevelDuration
+ * @return LevelDuration 
  */
 LevelDuration subghz_protocol_encoder_raw_yield(void* context);
 

lib/subghz/protocols/secplus_v2.c

@@ -261,16 +261,16 @@ static bool
     data = order << 4 | invert;
     int k = 0;
     for(int i = 6; i >= 0; i -= 2) {
-        roll_array[k++] = (data >> i) & 0x03;
-        if(roll_array[k] == 3) {
+        roll_array[k] = (data >> i) & 0x03;
+        if(roll_array[k++] == 3) {
             FURI_LOG_E(TAG, "Roll_Array FAIL");
             return false;
         }
     }
 
     for(int i = 8; i >= 0; i -= 2) {
-        roll_array[k++] = (p[2] >> i) & 0x03;
-        if(roll_array[k] == 3) {
+        roll_array[k] = (p[2] >> i) & 0x03;
+        if(roll_array[k++] == 3) {
             FURI_LOG_E(TAG, "Roll_Array FAIL");
             return false;
         }

lib/subghz/receiver.c

@@ -108,11 +108,6 @@ void subghz_receiver_set_filter(SubGhzReceiver* instance, SubGhzProtocolFlag fil
     instance->filter = filter;
 }
 
-SubGhzProtocolFlag subghz_receiver_get_filter(SubGhzReceiver* instance) {
-    furi_assert(instance);
-    return instance->filter;
-}
-
 SubGhzProtocolDecoderBase* subghz_receiver_search_decoder_base_by_name(
     SubGhzReceiver* instance,
     const char* decoder_name) {

lib/subghz/receiver.h

@@ -59,13 +59,6 @@ void subghz_receiver_set_rx_callback(
  */
 void subghz_receiver_set_filter(SubGhzReceiver* instance, SubGhzProtocolFlag filter);
 
-/**
- * Get the filter of receivers that will work at the moment.
- * @param instance Pointer to a SubGhzReceiver instance
- * @return filter Filter, SubGhzProtocolFlag
- */
-SubGhzProtocolFlag subghz_receiver_get_filter(SubGhzReceiver* instance);
-
 /**
  * Search for a cattery by his name.
  * @param instance Pointer to a SubGhzReceiver instance

lib/subghz/subghz_tx_rx_worker.c

@@ -70,7 +70,7 @@ bool subghz_tx_rx_worker_rx(SubGhzTxRxWorker* instance, uint8_t* data, uint8_t*
         furi_delay_tick(1);
     }
     //waiting for reception to complete
-    while(furi_hal_gpio_read(&gpio_cc1101_g0)) {
+    while(furi_hal_gpio_read(furi_hal_subghz.cc1101_g0_pin)) {
         furi_delay_tick(1);
         if(!--timeout) {
             FURI_LOG_W(TAG, "RX cc1101_g0 timeout");
@@ -104,14 +104,16 @@ void subghz_tx_rx_worker_tx(SubGhzTxRxWorker* instance, uint8_t* data, size_t si
     furi_hal_subghz_write_packet(data, size);
     furi_hal_subghz_tx(); //start send
     instance->status = SubGhzTxRxWorkerStatusTx;
-    while(!furi_hal_gpio_read(&gpio_cc1101_g0)) { // Wait for GDO0 to be set -> sync transmitted
+    while(!furi_hal_gpio_read(
+        furi_hal_subghz.cc1101_g0_pin)) { // Wait for GDO0 to be set -> sync transmitted
         furi_delay_tick(1);
         if(!--timeout) {
             FURI_LOG_W(TAG, "TX !cc1101_g0 timeout");
             break;
         }
     }
-    while(furi_hal_gpio_read(&gpio_cc1101_g0)) { // Wait for GDO0 to be cleared -> end of packet
+    while(furi_hal_gpio_read(
+        furi_hal_subghz.cc1101_g0_pin)) { // Wait for GDO0 to be cleared -> end of packet
         furi_delay_tick(1);
         if(!--timeout) {
             FURI_LOG_W(TAG, "TX cc1101_g0 timeout");
@@ -134,7 +136,7 @@ static int32_t subghz_tx_rx_worker_thread(void* context) {
     furi_hal_subghz_idle();
     furi_hal_subghz_load_preset(FuriHalSubGhzPresetGFSK9_99KbAsync);
     //furi_hal_subghz_load_preset(FuriHalSubGhzPresetMSK99_97KbAsync);
-    furi_hal_gpio_init(&gpio_cc1101_g0, GpioModeInput, GpioPullNo, GpioSpeedLow);
+    furi_hal_gpio_init(furi_hal_subghz.cc1101_g0_pin, GpioModeInput, GpioPullNo, GpioSpeedLow);
 
     furi_hal_subghz_set_frequency_and_path(instance->frequency);
     furi_hal_subghz_flush_rx();
@@ -233,7 +235,7 @@ bool subghz_tx_rx_worker_start(SubGhzTxRxWorker* instance, uint32_t frequency) {
 
     instance->worker_running = true;
 
-    if(furi_hal_region_is_frequency_allowed(frequency)) {
+    if(furi_hal_subghz_is_tx_allowed(frequency)) {
         instance->frequency = frequency;
         res = true;
     }

lib/subghz/types.h

@@ -77,6 +77,7 @@ typedef enum {
     SubGhzProtocolTypeRAW,
     SubGhzProtocolWeatherStation,
     SubGhzProtocolCustom,
+    SubGhzProtocolTypeBinRAW,
 } SubGhzProtocolType;
 
 typedef enum {