[FL-2627] Flipper applications: SDK, build and debug system (#1387)

* Added support for running applications from SD card (FAPs - Flipper Application Packages) * Added plugin_dist target for fbt to build FAPs * All apps of type FlipperAppType.EXTERNAL and FlipperAppType.PLUGIN are built as FAPs by default * Updated VSCode configuration for new fbt features - re-deploy stock configuration to use them * Added debugging support for FAPs with fbt debug & VSCode * Added public firmware API with automated versioning Co-authored-by: hedger <hedger@users.noreply.github.com> Co-authored-by: SG <who.just.the.doctor@gmail.com> Co-authored-by: あく <alleteam@gmail.com>
2022-09-15 02:11:38 +10:00
parent 0f6f9ad52e
commit b9a766d909
895 changed files with 8862 additions and 1465 deletions
--- a/applications/main/subghz/scenes/subghz_scene.c
+++ b/applications/main/subghz/scenes/subghz_scene.c
@@ -0,0 +1,30 @@
+#include "subghz_scene.h"
+
+// Generate scene on_enter handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_enter,
+void (*const subghz_on_enter_handlers[])(void*) = {
+#include "subghz_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Generate scene on_event handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_event,
+bool (*const subghz_on_event_handlers[])(void* context, SceneManagerEvent event) = {
+#include "subghz_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Generate scene on_exit handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_exit,
+void (*const subghz_on_exit_handlers[])(void* context) = {
+#include "subghz_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Initialize scene handlers configuration structure
+const SceneManagerHandlers subghz_scene_handlers = {
+    .on_enter_handlers = subghz_on_enter_handlers,
+    .on_event_handlers = subghz_on_event_handlers,
+    .on_exit_handlers = subghz_on_exit_handlers,
+    .scene_num = SubGhzSceneNum,
+};
--- a/applications/main/subghz/scenes/subghz_scene.h
+++ b/applications/main/subghz/scenes/subghz_scene.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <gui/scene_manager.h>
+
+// Generate scene id and total number
+#define ADD_SCENE(prefix, name, id) SubGhzScene##id,
+typedef enum {
+#include "subghz_scene_config.h"
+    SubGhzSceneNum,
+} SubGhzScene;
+#undef ADD_SCENE
+
+extern const SceneManagerHandlers subghz_scene_handlers;
+
+// Generate scene on_enter handlers declaration
+#define ADD_SCENE(prefix, name, id) void prefix##_scene_##name##_on_enter(void*);
+#include "subghz_scene_config.h"
+#undef ADD_SCENE
+
+// Generate scene on_event handlers declaration
+#define ADD_SCENE(prefix, name, id) \
+    bool prefix##_scene_##name##_on_event(void* context, SceneManagerEvent event);
+#include "subghz_scene_config.h"
+#undef ADD_SCENE
+
+// Generate scene on_exit handlers declaration
+#define ADD_SCENE(prefix, name, id) void prefix##_scene_##name##_on_exit(void* context);
+#include "subghz_scene_config.h"
+#undef ADD_SCENE
--- a/applications/main/subghz/scenes/subghz_scene_config.h
+++ b/applications/main/subghz/scenes/subghz_scene_config.h
@@ -0,0 +1,25 @@
+ADD_SCENE(subghz, start, Start)
+ADD_SCENE(subghz, receiver, Receiver)
+ADD_SCENE(subghz, receiver_config, ReceiverConfig)
+ADD_SCENE(subghz, receiver_info, ReceiverInfo)
+ADD_SCENE(subghz, save_name, SaveName)
+ADD_SCENE(subghz, save_success, SaveSuccess)
+ADD_SCENE(subghz, saved, Saved)
+ADD_SCENE(subghz, transmitter, Transmitter)
+ADD_SCENE(subghz, show_error, ShowError)
+ADD_SCENE(subghz, show_error_sub, ShowErrorSub)
+ADD_SCENE(subghz, show_only_rx, ShowOnlyRx)
+ADD_SCENE(subghz, saved_menu, SavedMenu)
+ADD_SCENE(subghz, delete, Delete)
+ADD_SCENE(subghz, delete_success, DeleteSuccess)
+ADD_SCENE(subghz, test, Test)
+ADD_SCENE(subghz, test_static, TestStatic)
+ADD_SCENE(subghz, test_carrier, TestCarrier)
+ADD_SCENE(subghz, test_packet, TestPacket)
+ADD_SCENE(subghz, set_type, SetType)
+ADD_SCENE(subghz, frequency_analyzer, FrequencyAnalyzer)
+ADD_SCENE(subghz, read_raw, ReadRAW)
+ADD_SCENE(subghz, more_raw, MoreRAW)
+ADD_SCENE(subghz, delete_raw, DeleteRAW)
+ADD_SCENE(subghz, need_saving, NeedSaving)
+ADD_SCENE(subghz, rpc, Rpc)
--- a/applications/main/subghz/scenes/subghz_scene_delete.c
+++ b/applications/main/subghz/scenes/subghz_scene_delete.c
@@ -0,0 +1,68 @@
+#include "../subghz_i.h"
+#include "../helpers/subghz_custom_event.h"
+
+void subghz_scene_delete_callback(GuiButtonType result, InputType type, void* context) {
+    furi_assert(context);
+    SubGhz* subghz = context;
+    if((result == GuiButtonTypeRight) && (type == InputTypeShort)) {
+        view_dispatcher_send_custom_event(subghz->view_dispatcher, SubGhzCustomEventSceneDelete);
+    }
+}
+
+void subghz_scene_delete_on_enter(void* context) {
+    SubGhz* subghz = context;
+    string_t frequency_str;
+    string_t modulation_str;
+    string_t text;
+
+    string_init(frequency_str);
+    string_init(modulation_str);
+    string_init(text);
+
+    subghz_get_frequency_modulation(subghz, frequency_str, modulation_str);
+    widget_add_string_element(
+        subghz->widget, 78, 0, AlignLeft, AlignTop, FontSecondary, string_get_cstr(frequency_str));
+
+    widget_add_string_element(
+        subghz->widget,
+        113,
+        0,
+        AlignLeft,
+        AlignTop,
+        FontSecondary,
+        string_get_cstr(modulation_str));
+    subghz_protocol_decoder_base_get_string(subghz->txrx->decoder_result, text);
+    widget_add_string_multiline_element(
+        subghz->widget, 0, 0, AlignLeft, AlignTop, FontSecondary, string_get_cstr(text));
+
+    string_clear(frequency_str);
+    string_clear(modulation_str);
+    string_clear(text);
+
+    widget_add_button_element(
+        subghz->widget, GuiButtonTypeRight, "Delete", subghz_scene_delete_callback, subghz);
+
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdWidget);
+}
+
+bool subghz_scene_delete_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubGhzCustomEventSceneDelete) {
+            string_set(subghz->file_path_tmp, subghz->file_path);
+            if(subghz_delete_file(subghz)) {
+                scene_manager_next_scene(subghz->scene_manager, SubGhzSceneDeleteSuccess);
+            } else {
+                scene_manager_search_and_switch_to_previous_scene(
+                    subghz->scene_manager, SubGhzSceneStart);
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
+void subghz_scene_delete_on_exit(void* context) {
+    SubGhz* subghz = context;
+    widget_reset(subghz->widget);
+}
--- a/applications/main/subghz/scenes/subghz_scene_delete_raw.c
+++ b/applications/main/subghz/scenes/subghz_scene_delete_raw.c
@@ -0,0 +1,82 @@
+#include "../subghz_i.h"
+#include "../helpers/subghz_custom_event.h"
+
+void subghz_scene_delete_raw_callback(GuiButtonType result, InputType type, void* context) {
+    furi_assert(context);
+    SubGhz* subghz = context;
+    if((result == GuiButtonTypeRight) && (type == InputTypeShort)) {
+        view_dispatcher_send_custom_event(
+            subghz->view_dispatcher, SubGhzCustomEventSceneDeleteRAW);
+    } else if((result == GuiButtonTypeLeft) && (type == InputTypeShort)) {
+        view_dispatcher_send_custom_event(
+            subghz->view_dispatcher, SubGhzCustomEventSceneDeleteRAWBack);
+    }
+}
+
+void subghz_scene_delete_raw_on_enter(void* context) {
+    SubGhz* subghz = context;
+    string_t frequency_str;
+    string_t modulation_str;
+
+    string_init(frequency_str);
+    string_init(modulation_str);
+
+    char delete_str[SUBGHZ_MAX_LEN_NAME + 16];
+    string_t file_name;
+    string_init(file_name);
+    path_extract_filename(subghz->file_path, file_name, true);
+    snprintf(delete_str, sizeof(delete_str), "\e#Delete %s?\e#", string_get_cstr(file_name));
+    string_clear(file_name);
+
+    widget_add_text_box_element(
+        subghz->widget, 0, 0, 128, 23, AlignCenter, AlignCenter, delete_str, false);
+
+    widget_add_string_element(
+        subghz->widget, 38, 25, AlignLeft, AlignTop, FontSecondary, "RAW signal");
+    subghz_get_frequency_modulation(subghz, frequency_str, modulation_str);
+    widget_add_string_element(
+        subghz->widget, 35, 37, AlignLeft, AlignTop, FontSecondary, string_get_cstr(frequency_str));
+
+    widget_add_string_element(
+        subghz->widget,
+        72,
+        37,
+        AlignLeft,
+        AlignTop,
+        FontSecondary,
+        string_get_cstr(modulation_str));
+
+    string_clear(frequency_str);
+    string_clear(modulation_str);
+
+    widget_add_button_element(
+        subghz->widget, GuiButtonTypeRight, "Delete", subghz_scene_delete_raw_callback, subghz);
+    widget_add_button_element(
+        subghz->widget, GuiButtonTypeLeft, "Back", subghz_scene_delete_raw_callback, subghz);
+
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdWidget);
+}
+
+bool subghz_scene_delete_raw_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubGhzCustomEventSceneDeleteRAW) {
+            string_set(subghz->file_path_tmp, subghz->file_path);
+            if(subghz_delete_file(subghz)) {
+                scene_manager_next_scene(subghz->scene_manager, SubGhzSceneDeleteSuccess);
+            } else {
+                scene_manager_search_and_switch_to_previous_scene(
+                    subghz->scene_manager, SubGhzSceneStart);
+            }
+            return true;
+        } else if(event.event == SubGhzCustomEventSceneDeleteRAWBack) {
+            return scene_manager_previous_scene(subghz->scene_manager);
+        }
+    }
+    return false;
+}
+
+void subghz_scene_delete_raw_on_exit(void* context) {
+    SubGhz* subghz = context;
+    widget_reset(subghz->widget);
+}
--- a/applications/main/subghz/scenes/subghz_scene_delete_success.c
+++ b/applications/main/subghz/scenes/subghz_scene_delete_success.c
@@ -0,0 +1,57 @@
+#include "../subghz_i.h"
+#include "../helpers/subghz_custom_event.h"
+
+void subghz_scene_delete_success_popup_callback(void* context) {
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(
+        subghz->view_dispatcher, SubGhzCustomEventSceneDeleteSuccess);
+}
+
+void subghz_scene_delete_success_on_enter(void* context) {
+    SubGhz* subghz = context;
+
+    // Setup view
+    Popup* popup = subghz->popup;
+    popup_set_icon(popup, 0, 2, &I_DolphinMafia_115x62);
+    popup_set_header(popup, "Deleted", 83, 19, AlignLeft, AlignBottom);
+    popup_set_timeout(popup, 1500);
+    popup_set_context(popup, subghz);
+    popup_set_callback(popup, subghz_scene_delete_success_popup_callback);
+    popup_enable_timeout(popup);
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdPopup);
+}
+
+bool subghz_scene_delete_success_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubGhzCustomEventSceneDeleteSuccess) {
+            if(scene_manager_search_and_switch_to_previous_scene(
+                   subghz->scene_manager, SubGhzSceneReadRAW)) {
+                scene_manager_next_scene(subghz->scene_manager, SubGhzSceneReadRAW);
+            } else if(scene_manager_search_and_switch_to_previous_scene(
+                          subghz->scene_manager, SubGhzSceneSaved)) {
+                scene_manager_next_scene(subghz->scene_manager, SubGhzSceneSaved);
+            } else {
+                scene_manager_search_and_switch_to_previous_scene(
+                    subghz->scene_manager, SubGhzSceneStart);
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
+void subghz_scene_delete_success_on_exit(void* context) {
+    SubGhz* subghz = context;
+
+    // Clear view
+    Popup* popup = subghz->popup;
+    popup_set_header(popup, NULL, 0, 0, AlignCenter, AlignBottom);
+    popup_set_text(popup, NULL, 0, 0, AlignCenter, AlignTop);
+    popup_set_icon(popup, 0, 0, NULL);
+    popup_set_callback(popup, NULL);
+    popup_set_context(popup, NULL);
+    popup_set_timeout(popup, 0);
+    popup_disable_timeout(popup);
+}
--- a/applications/main/subghz/scenes/subghz_scene_frequency_analyzer.c
+++ b/applications/main/subghz/scenes/subghz_scene_frequency_analyzer.c
@@ -0,0 +1,36 @@
+#include "../subghz_i.h"
+#include "../views/subghz_frequency_analyzer.h"
+#include <dolphin/dolphin.h>
+
+void subghz_scene_frequency_analyzer_callback(SubGhzCustomEvent event, void* context) {
+    furi_assert(context);
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, event);
+}
+
+void subghz_scene_frequency_analyzer_on_enter(void* context) {
+    SubGhz* subghz = context;
+    DOLPHIN_DEED(DolphinDeedSubGhzFrequencyAnalyzer);
+    subghz_frequency_analyzer_set_callback(
+        subghz->subghz_frequency_analyzer, subghz_scene_frequency_analyzer_callback, subghz);
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdFrequencyAnalyzer);
+}
+
+bool subghz_scene_frequency_analyzer_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubGhzCustomEventSceneAnalyzerLock) {
+            notification_message(subghz->notifications, &sequence_set_green_255);
+            return true;
+        } else if(event.event == SubGhzCustomEventSceneAnalyzerUnlock) {
+            notification_message(subghz->notifications, &sequence_reset_rgb);
+            return true;
+        }
+    }
+    return false;
+}
+
+void subghz_scene_frequency_analyzer_on_exit(void* context) {
+    SubGhz* subghz = context;
+    notification_message(subghz->notifications, &sequence_reset_rgb);
+}
--- a/applications/main/subghz/scenes/subghz_scene_more_raw.c
+++ b/applications/main/subghz/scenes/subghz_scene_more_raw.c
@@ -0,0 +1,61 @@
+#include "../subghz_i.h"
+
+enum SubmenuIndex {
+    SubmenuIndexEdit,
+    SubmenuIndexDelete,
+};
+
+void subghz_scene_more_raw_submenu_callback(void* context, uint32_t index) {
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, index);
+}
+
+void subghz_scene_more_raw_on_enter(void* context) {
+    SubGhz* subghz = context;
+
+    submenu_add_item(
+        subghz->submenu,
+        "Rename",
+        SubmenuIndexEdit,
+        subghz_scene_more_raw_submenu_callback,
+        subghz);
+
+    submenu_add_item(
+        subghz->submenu,
+        "Delete",
+        SubmenuIndexDelete,
+        subghz_scene_more_raw_submenu_callback,
+        subghz);
+
+    submenu_set_selected_item(
+        subghz->submenu, scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneMoreRAW));
+
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdMenu);
+}
+
+bool subghz_scene_more_raw_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubmenuIndexDelete) {
+            scene_manager_set_scene_state(
+                subghz->scene_manager, SubGhzSceneReadRAW, SubGhzCustomEventManagerNoSet);
+            scene_manager_set_scene_state(
+                subghz->scene_manager, SubGhzSceneMoreRAW, SubmenuIndexDelete);
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneDeleteRAW);
+            return true;
+        } else if(event.event == SubmenuIndexEdit) {
+            string_reset(subghz->file_path_tmp);
+            scene_manager_set_scene_state(
+                subghz->scene_manager, SubGhzSceneMoreRAW, SubmenuIndexEdit);
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneSaveName);
+            return true;
+        }
+    }
+    return false;
+}
+
+void subghz_scene_more_raw_on_exit(void* context) {
+    SubGhz* subghz = context;
+    submenu_reset(subghz->submenu);
+}
--- a/applications/main/subghz/scenes/subghz_scene_need_saving.c
+++ b/applications/main/subghz/scenes/subghz_scene_need_saving.c
@@ -0,0 +1,73 @@
+#include "../subghz_i.h"
+#include "../helpers/subghz_custom_event.h"
+
+void subghz_scene_need_saving_callback(GuiButtonType result, InputType type, void* context) {
+    furi_assert(context);
+    SubGhz* subghz = context;
+
+    if((result == GuiButtonTypeRight) && (type == InputTypeShort)) {
+        view_dispatcher_send_custom_event(subghz->view_dispatcher, SubGhzCustomEventSceneStay);
+    } else if((result == GuiButtonTypeLeft) && (type == InputTypeShort)) {
+        view_dispatcher_send_custom_event(subghz->view_dispatcher, SubGhzCustomEventSceneExit);
+    }
+}
+
+void subghz_scene_need_saving_on_enter(void* context) {
+    SubGhz* subghz = context;
+
+    widget_add_string_multiline_element(
+        subghz->widget, 64, 13, AlignCenter, AlignCenter, FontPrimary, "Exit to Sub-GHz menu?");
+    widget_add_string_multiline_element(
+        subghz->widget,
+        64,
+        32,
+        AlignCenter,
+        AlignCenter,
+        FontSecondary,
+        "All unsaved will be\nlost.");
+
+    widget_add_button_element(
+        subghz->widget, GuiButtonTypeRight, "Stay", subghz_scene_need_saving_callback, subghz);
+    widget_add_button_element(
+        subghz->widget, GuiButtonTypeLeft, "Exit", subghz_scene_need_saving_callback, subghz);
+
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdWidget);
+}
+
+bool subghz_scene_need_saving_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+    if(event.type == SceneManagerEventTypeBack) {
+        subghz->txrx->rx_key_state = SubGhzRxKeyStateBack;
+        scene_manager_previous_scene(subghz->scene_manager);
+        return true;
+    } else if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubGhzCustomEventSceneStay) {
+            subghz->txrx->rx_key_state = SubGhzRxKeyStateBack;
+            scene_manager_previous_scene(subghz->scene_manager);
+            return true;
+        } else if(event.event == SubGhzCustomEventSceneExit) {
+            if(subghz->txrx->rx_key_state == SubGhzRxKeyStateExit) {
+                subghz->txrx->rx_key_state = SubGhzRxKeyStateIDLE;
+                subghz_preset_init(
+                    subghz,
+                    "AM650",
+                    subghz_setting_get_default_frequency(subghz->setting),
+                    NULL,
+                    0);
+                scene_manager_search_and_switch_to_previous_scene(
+                    subghz->scene_manager, SubGhzSceneStart);
+            } else {
+                subghz->txrx->rx_key_state = SubGhzRxKeyStateIDLE;
+                scene_manager_previous_scene(subghz->scene_manager);
+            }
+
+            return true;
+        }
+    }
+    return false;
+}
+
+void subghz_scene_need_saving_on_exit(void* context) {
+    SubGhz* subghz = context;
+    widget_reset(subghz->widget);
+}
--- a/applications/main/subghz/scenes/subghz_scene_read_raw.c
+++ b/applications/main/subghz/scenes/subghz_scene_read_raw.c
@@ -0,0 +1,342 @@
+#include "../subghz_i.h"
+#include "../views/subghz_read_raw.h"
+#include <dolphin/dolphin.h>
+#include <lib/subghz/protocols/raw.h>
+#include <lib/toolbox/path.h>
+
+#define RAW_FILE_NAME "Raw_signal_"
+#define TAG "SubGhzSceneReadRAW"
+
+bool subghz_scene_read_raw_update_filename(SubGhz* subghz) {
+    bool ret = false;
+    //set the path to read the file
+    string_t temp_str;
+    string_init(temp_str);
+    do {
+        if(!flipper_format_rewind(subghz->txrx->fff_data)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+
+        if(!flipper_format_read_string(subghz->txrx->fff_data, "File_name", temp_str)) {
+            FURI_LOG_E(TAG, "Missing File_name");
+            break;
+        }
+
+        string_set(subghz->file_path, temp_str);
+
+        ret = true;
+    } while(false);
+
+    string_clear(temp_str);
+    return ret;
+}
+
+static void subghz_scene_read_raw_update_statusbar(void* context) {
+    furi_assert(context);
+    SubGhz* subghz = context;
+
+    string_t frequency_str;
+    string_t modulation_str;
+
+    string_init(frequency_str);
+    string_init(modulation_str);
+
+    subghz_get_frequency_modulation(subghz, frequency_str, modulation_str);
+    subghz_read_raw_add_data_statusbar(
+        subghz->subghz_read_raw, string_get_cstr(frequency_str), string_get_cstr(modulation_str));
+
+    string_clear(frequency_str);
+    string_clear(modulation_str);
+}
+
+void subghz_scene_read_raw_callback(SubGhzCustomEvent event, void* context) {
+    furi_assert(context);
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, event);
+}
+
+void subghz_scene_read_raw_callback_end_tx(void* context) {
+    furi_assert(context);
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(
+        subghz->view_dispatcher, SubGhzCustomEventViewReadRAWSendStop);
+}
+
+void subghz_scene_read_raw_on_enter(void* context) {
+    SubGhz* subghz = context;
+    string_t file_name;
+    string_init(file_name);
+
+    switch(subghz->txrx->rx_key_state) {
+    case SubGhzRxKeyStateBack:
+        subghz_read_raw_set_status(subghz->subghz_read_raw, SubGhzReadRAWStatusIDLE, "");
+        break;
+    case SubGhzRxKeyStateRAWLoad:
+        path_extract_filename(subghz->file_path, file_name, true);
+        subghz_read_raw_set_status(
+            subghz->subghz_read_raw, SubGhzReadRAWStatusLoadKeyTX, string_get_cstr(file_name));
+        subghz->txrx->rx_key_state = SubGhzRxKeyStateIDLE;
+        break;
+    case SubGhzRxKeyStateRAWSave:
+        path_extract_filename(subghz->file_path, file_name, true);
+        subghz_read_raw_set_status(
+            subghz->subghz_read_raw, SubGhzReadRAWStatusSaveKey, string_get_cstr(file_name));
+        subghz->txrx->rx_key_state = SubGhzRxKeyStateIDLE;
+        break;
+    default:
+        subghz_read_raw_set_status(subghz->subghz_read_raw, SubGhzReadRAWStatusStart, "");
+        subghz->txrx->rx_key_state = SubGhzRxKeyStateIDLE;
+        break;
+    }
+    string_clear(file_name);
+    subghz_scene_read_raw_update_statusbar(subghz);
+
+    //set callback view raw
+    subghz_read_raw_set_callback(subghz->subghz_read_raw, subghz_scene_read_raw_callback, subghz);
+
+    subghz->txrx->decoder_result = subghz_receiver_search_decoder_base_by_name(
+        subghz->txrx->receiver, SUBGHZ_PROTOCOL_RAW_NAME);
+    furi_assert(subghz->txrx->decoder_result);
+
+    //set filter RAW feed
+    subghz_receiver_set_filter(subghz->txrx->receiver, SubGhzProtocolFlag_RAW);
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdReadRAW);
+}
+
+bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+    bool consumed = false;
+    if(event.type == SceneManagerEventTypeCustom) {
+        switch(event.event) {
+        case SubGhzCustomEventViewReadRAWBack:
+            //Stop TX
+            if(subghz->txrx->txrx_state == SubGhzTxRxStateTx) {
+                subghz_tx_stop(subghz);
+                subghz_sleep(subghz);
+            }
+            //Stop RX
+            if(subghz->txrx->txrx_state == SubGhzTxRxStateRx) {
+                subghz_rx_end(subghz);
+                subghz_sleep(subghz);
+            };
+            //Stop save file
+            subghz_protocol_raw_save_to_file_stop(
+                (SubGhzProtocolDecoderRAW*)subghz->txrx->decoder_result);
+            subghz->state_notifications = SubGhzNotificationStateIDLE;
+            //needed save?
+            if((subghz->txrx->rx_key_state == SubGhzRxKeyStateAddKey) ||
+               (subghz->txrx->rx_key_state == SubGhzRxKeyStateBack)) {
+                subghz->txrx->rx_key_state = SubGhzRxKeyStateExit;
+                scene_manager_next_scene(subghz->scene_manager, SubGhzSceneNeedSaving);
+            } else {
+                //Restore default setting
+                subghz_preset_init(
+                    subghz,
+                    "AM650",
+                    subghz_setting_get_default_frequency(subghz->setting),
+                    NULL,
+                    0);
+                if(!scene_manager_search_and_switch_to_previous_scene(
+                       subghz->scene_manager, SubGhzSceneSaved)) {
+                    if(!scene_manager_search_and_switch_to_previous_scene(
+                           subghz->scene_manager, SubGhzSceneStart)) {
+                        scene_manager_stop(subghz->scene_manager);
+                        view_dispatcher_stop(subghz->view_dispatcher);
+                    }
+                }
+            }
+            consumed = true;
+            break;
+
+        case SubGhzCustomEventViewReadRAWTXRXStop:
+            //Stop TX
+            if(subghz->txrx->txrx_state == SubGhzTxRxStateTx) {
+                subghz_tx_stop(subghz);
+                subghz_sleep(subghz);
+            }
+            //Stop RX
+            if(subghz->txrx->txrx_state == SubGhzTxRxStateRx) {
+                subghz_rx_end(subghz);
+                subghz_sleep(subghz);
+            };
+            subghz->state_notifications = SubGhzNotificationStateIDLE;
+            consumed = true;
+            break;
+
+        case SubGhzCustomEventViewReadRAWConfig:
+            scene_manager_set_scene_state(
+                subghz->scene_manager, SubGhzSceneReadRAW, SubGhzCustomEventManagerSet);
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneReceiverConfig);
+            consumed = true;
+            break;
+
+        case SubGhzCustomEventViewReadRAWErase:
+            if(subghz->txrx->rx_key_state == SubGhzRxKeyStateAddKey) {
+                if(subghz_scene_read_raw_update_filename(subghz)) {
+                    string_set(subghz->file_path_tmp, subghz->file_path);
+                    subghz_delete_file(subghz);
+                }
+            }
+            subghz->txrx->rx_key_state = SubGhzRxKeyStateIDLE;
+            notification_message(subghz->notifications, &sequence_reset_rgb);
+            consumed = true;
+            break;
+
+        case SubGhzCustomEventViewReadRAWMore:
+            if(subghz_scene_read_raw_update_filename(subghz)) {
+                scene_manager_set_scene_state(
+                    subghz->scene_manager, SubGhzSceneReadRAW, SubGhzCustomEventManagerSet);
+                subghz->txrx->rx_key_state = SubGhzRxKeyStateRAWLoad;
+                scene_manager_next_scene(subghz->scene_manager, SubGhzSceneMoreRAW);
+                consumed = true;
+            } else {
+                furi_crash("SubGhz: RAW file name update error.");
+            }
+            break;
+
+        case SubGhzCustomEventViewReadRAWSendStart:
+
+            if(subghz_scene_read_raw_update_filename(subghz)) {
+                //start send
+                subghz->state_notifications = SubGhzNotificationStateIDLE;
+                if(subghz->txrx->txrx_state == SubGhzTxRxStateRx) {
+                    subghz_rx_end(subghz);
+                }
+                if((subghz->txrx->txrx_state == SubGhzTxRxStateIDLE) ||
+                   (subghz->txrx->txrx_state == SubGhzTxRxStateSleep)) {
+                    if(!subghz_tx_start(subghz, subghz->txrx->fff_data)) {
+                        subghz->txrx->rx_key_state = SubGhzRxKeyStateBack;
+                        scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowOnlyRx);
+                    } else {
+                        DOLPHIN_DEED(DolphinDeedSubGhzSend);
+                        // set callback end tx
+                        subghz_protocol_raw_file_encoder_worker_set_callback_end(
+                            (SubGhzProtocolEncoderRAW*)subghz_transmitter_get_protocol_instance(
+                                subghz->txrx->transmitter),
+                            subghz_scene_read_raw_callback_end_tx,
+                            subghz);
+                        subghz->state_notifications = SubGhzNotificationStateTx;
+                    }
+                }
+            }
+            consumed = true;
+            break;
+
+        case SubGhzCustomEventViewReadRAWSendStop:
+            subghz->state_notifications = SubGhzNotificationStateIDLE;
+            if(subghz->txrx->txrx_state == SubGhzTxRxStateTx) {
+                subghz_tx_stop(subghz);
+                subghz_sleep(subghz);
+            }
+            subghz_read_raw_stop_send(subghz->subghz_read_raw);
+            consumed = true;
+            break;
+
+        case SubGhzCustomEventViewReadRAWIDLE:
+            if(subghz->txrx->txrx_state == SubGhzTxRxStateRx) {
+                subghz_rx_end(subghz);
+                subghz_sleep(subghz);
+            };
+
+            size_t spl_count = subghz_protocol_raw_get_sample_write(
+                (SubGhzProtocolDecoderRAW*)subghz->txrx->decoder_result);
+
+            subghz_protocol_raw_save_to_file_stop(
+                (SubGhzProtocolDecoderRAW*)subghz->txrx->decoder_result);
+
+            string_t temp_str;
+            string_init(temp_str);
+            string_printf(
+                temp_str, "%s/%s%s", SUBGHZ_RAW_FOLDER, RAW_FILE_NAME, SUBGHZ_APP_EXTENSION);
+            subghz_protocol_raw_gen_fff_data(subghz->txrx->fff_data, string_get_cstr(temp_str));
+            string_clear(temp_str);
+
+            if(spl_count > 0) {
+                notification_message(subghz->notifications, &sequence_set_green_255);
+            } else {
+                notification_message(subghz->notifications, &sequence_reset_rgb);
+            }
+
+            subghz->state_notifications = SubGhzNotificationStateIDLE;
+            subghz->txrx->rx_key_state = SubGhzRxKeyStateAddKey;
+
+            consumed = true;
+            break;
+
+        case SubGhzCustomEventViewReadRAWREC:
+            if(subghz->txrx->rx_key_state != SubGhzRxKeyStateIDLE) {
+                scene_manager_next_scene(subghz->scene_manager, SubGhzSceneNeedSaving);
+            } else {
+                //subghz_get_preset_name(subghz, subghz->error_str);
+                if(subghz_protocol_raw_save_to_file_init(
+                       (SubGhzProtocolDecoderRAW*)subghz->txrx->decoder_result,
+                       RAW_FILE_NAME,
+                       subghz->txrx->preset)) {
+                    DOLPHIN_DEED(DolphinDeedSubGhzRawRec);
+                    if((subghz->txrx->txrx_state == SubGhzTxRxStateIDLE) ||
+                       (subghz->txrx->txrx_state == SubGhzTxRxStateSleep)) {
+                        subghz_begin(
+                            subghz,
+                            subghz_setting_get_preset_data_by_name(
+                                subghz->setting, string_get_cstr(subghz->txrx->preset->name)));
+                        subghz_rx(subghz, subghz->txrx->preset->frequency);
+                    }
+                    subghz->state_notifications = SubGhzNotificationStateRx;
+                    subghz->txrx->rx_key_state = SubGhzRxKeyStateAddKey;
+                } else {
+                    string_set_str(subghz->error_str, "Function requires\nan SD card.");
+                    scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowError);
+                }
+            }
+            consumed = true;
+            break;
+
+        case SubGhzCustomEventViewReadRAWSave:
+            if(subghz_scene_read_raw_update_filename(subghz)) {
+                scene_manager_set_scene_state(
+                    subghz->scene_manager, SubGhzSceneReadRAW, SubGhzCustomEventManagerSetRAW);
+                subghz->txrx->rx_key_state = SubGhzRxKeyStateBack;
+                scene_manager_next_scene(subghz->scene_manager, SubGhzSceneSaveName);
+            }
+            consumed = true;
+            break;
+
+        default:
+            break;
+        }
+    } else if(event.type == SceneManagerEventTypeTick) {
+        switch(subghz->state_notifications) {
+        case SubGhzNotificationStateRx:
+            notification_message(subghz->notifications, &sequence_blink_cyan_10);
+            subghz_read_raw_update_sample_write(
+                subghz->subghz_read_raw,
+                subghz_protocol_raw_get_sample_write(
+                    (SubGhzProtocolDecoderRAW*)subghz->txrx->decoder_result));
+            subghz_read_raw_add_data_rssi(subghz->subghz_read_raw, furi_hal_subghz_get_rssi());
+            break;
+        case SubGhzNotificationStateTx:
+            notification_message(subghz->notifications, &sequence_blink_magenta_10);
+            subghz_read_raw_update_sin(subghz->subghz_read_raw);
+            break;
+        default:
+            break;
+        }
+    }
+    return consumed;
+}
+
+void subghz_scene_read_raw_on_exit(void* context) {
+    SubGhz* subghz = context;
+
+    //Stop CC1101
+    if(subghz->txrx->txrx_state == SubGhzTxRxStateRx) {
+        subghz_rx_end(subghz);
+        subghz_sleep(subghz);
+    };
+    subghz->state_notifications = SubGhzNotificationStateIDLE;
+    notification_message(subghz->notifications, &sequence_reset_rgb);
+
+    //filter restoration
+    subghz_receiver_set_filter(subghz->txrx->receiver, SubGhzProtocolFlag_Decodable);
+}
--- a/applications/main/subghz/scenes/subghz_scene_receiver.c
+++ b/applications/main/subghz/scenes/subghz_scene_receiver.c
@@ -0,0 +1,230 @@
+#include "../subghz_i.h"
+#include "../views/receiver.h"
+
+static const NotificationSequence subghs_sequence_rx = {
+    &message_green_255,
+
+    &message_vibro_on,
+    &message_note_c6,
+    &message_delay_50,
+    &message_sound_off,
+    &message_vibro_off,
+
+    &message_delay_50,
+    NULL,
+};
+
+static const NotificationSequence subghs_sequence_rx_locked = {
+    &message_green_255,
+
+    &message_display_backlight_on,
+
+    &message_vibro_on,
+    &message_note_c6,
+    &message_delay_50,
+    &message_sound_off,
+    &message_vibro_off,
+
+    &message_delay_500,
+
+    &message_display_backlight_off,
+    NULL,
+};
+
+static void subghz_scene_receiver_update_statusbar(void* context) {
+    SubGhz* subghz = context;
+    string_t history_stat_str;
+    string_init(history_stat_str);
+    if(!subghz_history_get_text_space_left(subghz->txrx->history, history_stat_str)) {
+        string_t frequency_str;
+        string_t modulation_str;
+
+        string_init(frequency_str);
+        string_init(modulation_str);
+
+        subghz_get_frequency_modulation(subghz, frequency_str, modulation_str);
+
+        subghz_view_receiver_add_data_statusbar(
+            subghz->subghz_receiver,
+            string_get_cstr(frequency_str),
+            string_get_cstr(modulation_str),
+            string_get_cstr(history_stat_str));
+
+        string_clear(frequency_str);
+        string_clear(modulation_str);
+    } else {
+        subghz_view_receiver_add_data_statusbar(
+            subghz->subghz_receiver, string_get_cstr(history_stat_str), "", "");
+        subghz->state_notifications = SubGhzNotificationStateIDLE;
+    }
+    string_clear(history_stat_str);
+}
+
+void subghz_scene_receiver_callback(SubGhzCustomEvent event, void* context) {
+    furi_assert(context);
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, event);
+}
+
+static void subghz_scene_add_to_history_callback(
+    SubGhzReceiver* receiver,
+    SubGhzProtocolDecoderBase* decoder_base,
+    void* context) {
+    furi_assert(context);
+    SubGhz* subghz = context;
+    string_t str_buff;
+    string_init(str_buff);
+
+    if(subghz_history_add_to_history(subghz->txrx->history, decoder_base, subghz->txrx->preset)) {
+        string_reset(str_buff);
+
+        subghz->state_notifications = SubGhzNotificationStateRxDone;
+
+        subghz_history_get_text_item_menu(
+            subghz->txrx->history, str_buff, subghz_history_get_item(subghz->txrx->history) - 1);
+        subghz_view_receiver_add_item_to_menu(
+            subghz->subghz_receiver,
+            string_get_cstr(str_buff),
+            subghz_history_get_type_protocol(
+                subghz->txrx->history, subghz_history_get_item(subghz->txrx->history) - 1));
+
+        subghz_scene_receiver_update_statusbar(subghz);
+    }
+    subghz_receiver_reset(receiver);
+    string_clear(str_buff);
+    subghz->txrx->rx_key_state = SubGhzRxKeyStateAddKey;
+}
+
+void subghz_scene_receiver_on_enter(void* context) {
+    SubGhz* subghz = context;
+
+    string_t str_buff;
+    string_init(str_buff);
+
+    if(subghz->txrx->rx_key_state == SubGhzRxKeyStateIDLE) {
+        subghz_preset_init(
+            subghz, "AM650", subghz_setting_get_default_frequency(subghz->setting), NULL, 0);
+        subghz_history_reset(subghz->txrx->history);
+        subghz->txrx->rx_key_state = SubGhzRxKeyStateStart;
+    }
+
+    subghz_view_receiver_set_lock(subghz->subghz_receiver, subghz->lock);
+
+    //Load history to receiver
+    subghz_view_receiver_exit(subghz->subghz_receiver);
+    for(uint8_t i = 0; i < subghz_history_get_item(subghz->txrx->history); i++) {
+        string_reset(str_buff);
+        subghz_history_get_text_item_menu(subghz->txrx->history, str_buff, i);
+        subghz_view_receiver_add_item_to_menu(
+            subghz->subghz_receiver,
+            string_get_cstr(str_buff),
+            subghz_history_get_type_protocol(subghz->txrx->history, i));
+        subghz->txrx->rx_key_state = SubGhzRxKeyStateAddKey;
+    }
+    string_clear(str_buff);
+    subghz_scene_receiver_update_statusbar(subghz);
+    subghz_view_receiver_set_callback(
+        subghz->subghz_receiver, subghz_scene_receiver_callback, subghz);
+    subghz_receiver_set_rx_callback(
+        subghz->txrx->receiver, subghz_scene_add_to_history_callback, subghz);
+
+    subghz->state_notifications = SubGhzNotificationStateRx;
+    if(subghz->txrx->txrx_state == SubGhzTxRxStateRx) {
+        subghz_rx_end(subghz);
+    };
+    if((subghz->txrx->txrx_state == SubGhzTxRxStateIDLE) ||
+       (subghz->txrx->txrx_state == SubGhzTxRxStateSleep)) {
+        subghz_begin(
+            subghz,
+            subghz_setting_get_preset_data_by_name(
+                subghz->setting, string_get_cstr(subghz->txrx->preset->name)));
+        subghz_rx(subghz, subghz->txrx->preset->frequency);
+    }
+    subghz_view_receiver_set_idx_menu(subghz->subghz_receiver, subghz->txrx->idx_menu_chosen);
+
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdReceiver);
+}
+
+bool subghz_scene_receiver_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+    bool consumed = false;
+    if(event.type == SceneManagerEventTypeCustom) {
+        switch(event.event) {
+        case SubGhzCustomEventViewReceiverBack:
+            // Stop CC1101 Rx
+            subghz->state_notifications = SubGhzNotificationStateIDLE;
+            if(subghz->txrx->txrx_state == SubGhzTxRxStateRx) {
+                subghz_rx_end(subghz);
+                subghz_sleep(subghz);
+            };
+            subghz->txrx->hopper_state = SubGhzHopperStateOFF;
+            subghz->txrx->idx_menu_chosen = 0;
+            subghz_receiver_set_rx_callback(subghz->txrx->receiver, NULL, subghz);
+
+            if(subghz->txrx->rx_key_state == SubGhzRxKeyStateAddKey) {
+                subghz->txrx->rx_key_state = SubGhzRxKeyStateExit;
+                scene_manager_next_scene(subghz->scene_manager, SubGhzSceneNeedSaving);
+            } else {
+                subghz->txrx->rx_key_state = SubGhzRxKeyStateIDLE;
+                subghz_preset_init(
+                    subghz,
+                    "AM650",
+                    subghz_setting_get_default_frequency(subghz->setting),
+                    NULL,
+                    0);
+                scene_manager_search_and_switch_to_previous_scene(
+                    subghz->scene_manager, SubGhzSceneStart);
+            }
+            consumed = true;
+            break;
+        case SubGhzCustomEventViewReceiverOK:
+            subghz->txrx->idx_menu_chosen =
+                subghz_view_receiver_get_idx_menu(subghz->subghz_receiver);
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneReceiverInfo);
+            consumed = true;
+            break;
+        case SubGhzCustomEventViewReceiverConfig:
+            subghz->state_notifications = SubGhzNotificationStateIDLE;
+            subghz->txrx->idx_menu_chosen =
+                subghz_view_receiver_get_idx_menu(subghz->subghz_receiver);
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneReceiverConfig);
+            consumed = true;
+            break;
+        case SubGhzCustomEventViewReceiverOffDisplay:
+            notification_message(subghz->notifications, &sequence_display_backlight_off);
+            consumed = true;
+            break;
+        case SubGhzCustomEventViewReceiverUnlock:
+            subghz->lock = SubGhzLockOff;
+            consumed = true;
+            break;
+        default:
+            break;
+        }
+    } else if(event.type == SceneManagerEventTypeTick) {
+        if(subghz->txrx->hopper_state != SubGhzHopperStateOFF) {
+            subghz_hopper_update(subghz);
+            subghz_scene_receiver_update_statusbar(subghz);
+        }
+        switch(subghz->state_notifications) {
+        case SubGhzNotificationStateRx:
+            notification_message(subghz->notifications, &sequence_blink_cyan_10);
+            break;
+        case SubGhzNotificationStateRxDone:
+            if(subghz->lock != SubGhzLockOn) {
+                notification_message(subghz->notifications, &subghs_sequence_rx);
+            } else {
+                notification_message(subghz->notifications, &subghs_sequence_rx_locked);
+            }
+            subghz->state_notifications = SubGhzNotificationStateRx;
+            break;
+        default:
+            break;
+        }
+    }
+    return consumed;
+}
+
+void subghz_scene_receiver_on_exit(void* context) {
+    UNUSED(context);
+}
--- a/applications/main/subghz/scenes/subghz_scene_receiver_config.c
+++ b/applications/main/subghz/scenes/subghz_scene_receiver_config.c
@@ -0,0 +1,229 @@
+#include "../subghz_i.h"
+
+enum SubGhzSettingIndex {
+    SubGhzSettingIndexFrequency,
+    SubGhzSettingIndexHopping,
+    SubGhzSettingIndexModulation,
+    SubGhzSettingIndexLock,
+};
+
+#define HOPPING_COUNT 2
+const char* const hopping_text[HOPPING_COUNT] = {
+    "OFF",
+    "ON",
+};
+const uint32_t hopping_value[HOPPING_COUNT] = {
+    SubGhzHopperStateOFF,
+    SubGhzHopperStateRunnig,
+};
+
+uint8_t subghz_scene_receiver_config_next_frequency(const uint32_t value, void* context) {
+    furi_assert(context);
+    SubGhz* subghz = context;
+    uint8_t index = 0;
+    for(uint8_t i = 0; i < subghz_setting_get_frequency_count(subghz->setting); i++) {
+        if(value == subghz_setting_get_frequency(subghz->setting, i)) {
+            index = i;
+            break;
+        } else {
+            index = subghz_setting_get_frequency_default_index(subghz->setting);
+        }
+    }
+    return index;
+}
+
+uint8_t subghz_scene_receiver_config_next_preset(const char* preset_name, void* context) {
+    furi_assert(context);
+    SubGhz* subghz = context;
+    uint8_t index = 0;
+    for(uint8_t i = 0; i < subghz_setting_get_preset_count(subghz->setting); i++) {
+        if(!strcmp(subghz_setting_get_preset_name(subghz->setting, i), preset_name)) {
+            index = i;
+            break;
+        } else {
+            //  index = subghz_setting_get_frequency_default_index(subghz->setting);
+        }
+    }
+    return index;
+}
+
+uint8_t subghz_scene_receiver_config_hopper_value_index(
+    const uint32_t value,
+    const uint32_t values[],
+    uint8_t values_count,
+    void* context) {
+    furi_assert(context);
+    UNUSED(values_count);
+    SubGhz* subghz = context;
+
+    if(value == values[0]) {
+        return 0;
+    } else {
+        variable_item_set_current_value_text(
+            (VariableItem*)scene_manager_get_scene_state(
+                subghz->scene_manager, SubGhzSceneReceiverConfig),
+            " -----");
+        return 1;
+    }
+}
+
+static void subghz_scene_receiver_config_set_frequency(VariableItem* item) {
+    SubGhz* subghz = variable_item_get_context(item);
+    uint8_t index = variable_item_get_current_value_index(item);
+
+    if(subghz->txrx->hopper_state == SubGhzHopperStateOFF) {
+        char text_buf[10] = {0};
+        snprintf(
+            text_buf,
+            sizeof(text_buf),
+            "%lu.%02lu",
+            subghz_setting_get_frequency(subghz->setting, index) / 1000000,
+            (subghz_setting_get_frequency(subghz->setting, index) % 1000000) / 10000);
+        variable_item_set_current_value_text(item, text_buf);
+        subghz->txrx->preset->frequency = subghz_setting_get_frequency(subghz->setting, index);
+    } else {
+        variable_item_set_current_value_index(
+            item, subghz_setting_get_frequency_default_index(subghz->setting));
+    }
+}
+
+static void subghz_scene_receiver_config_set_preset(VariableItem* item) {
+    SubGhz* subghz = variable_item_get_context(item);
+    uint8_t index = variable_item_get_current_value_index(item);
+    variable_item_set_current_value_text(
+        item, subghz_setting_get_preset_name(subghz->setting, index));
+    subghz_preset_init(
+        subghz,
+        subghz_setting_get_preset_name(subghz->setting, index),
+        subghz->txrx->preset->frequency,
+        subghz_setting_get_preset_data(subghz->setting, index),
+        subghz_setting_get_preset_data_size(subghz->setting, index));
+}
+
+static void subghz_scene_receiver_config_set_hopping_running(VariableItem* item) {
+    SubGhz* subghz = variable_item_get_context(item);
+    uint8_t index = variable_item_get_current_value_index(item);
+
+    variable_item_set_current_value_text(item, hopping_text[index]);
+    if(hopping_value[index] == SubGhzHopperStateOFF) {
+        char text_buf[10] = {0};
+        snprintf(
+            text_buf,
+            sizeof(text_buf),
+            "%lu.%02lu",
+            subghz_setting_get_default_frequency(subghz->setting) / 1000000,
+            (subghz_setting_get_default_frequency(subghz->setting) % 1000000) / 10000);
+        variable_item_set_current_value_text(
+            (VariableItem*)scene_manager_get_scene_state(
+                subghz->scene_manager, SubGhzSceneReceiverConfig),
+            text_buf);
+        subghz->txrx->preset->frequency = subghz_setting_get_default_frequency(subghz->setting);
+        variable_item_set_current_value_index(
+            (VariableItem*)scene_manager_get_scene_state(
+                subghz->scene_manager, SubGhzSceneReceiverConfig),
+            subghz_setting_get_frequency_default_index(subghz->setting));
+    } else {
+        variable_item_set_current_value_text(
+            (VariableItem*)scene_manager_get_scene_state(
+                subghz->scene_manager, SubGhzSceneReceiverConfig),
+            " -----");
+        variable_item_set_current_value_index(
+            (VariableItem*)scene_manager_get_scene_state(
+                subghz->scene_manager, SubGhzSceneReceiverConfig),
+            subghz_setting_get_frequency_default_index(subghz->setting));
+    }
+
+    subghz->txrx->hopper_state = hopping_value[index];
+}
+
+static void subghz_scene_receiver_config_var_list_enter_callback(void* context, uint32_t index) {
+    furi_assert(context);
+    SubGhz* subghz = context;
+    if(index == SubGhzSettingIndexLock) {
+        view_dispatcher_send_custom_event(
+            subghz->view_dispatcher, SubGhzCustomEventSceneSettingLock);
+    }
+}
+
+void subghz_scene_receiver_config_on_enter(void* context) {
+    SubGhz* subghz = context;
+    VariableItem* item;
+    uint8_t value_index;
+
+    item = variable_item_list_add(
+        subghz->variable_item_list,
+        "Frequency:",
+        subghz_setting_get_frequency_count(subghz->setting),
+        subghz_scene_receiver_config_set_frequency,
+        subghz);
+    value_index =
+        subghz_scene_receiver_config_next_frequency(subghz->txrx->preset->frequency, subghz);
+    scene_manager_set_scene_state(
+        subghz->scene_manager, SubGhzSceneReceiverConfig, (uint32_t)item);
+    variable_item_set_current_value_index(item, value_index);
+    char text_buf[10] = {0};
+    snprintf(
+        text_buf,
+        sizeof(text_buf),
+        "%lu.%02lu",
+        subghz_setting_get_frequency(subghz->setting, value_index) / 1000000,
+        (subghz_setting_get_frequency(subghz->setting, value_index) % 1000000) / 10000);
+    variable_item_set_current_value_text(item, text_buf);
+
+    if(scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneReadRAW) !=
+       SubGhzCustomEventManagerSet) {
+        item = variable_item_list_add(
+            subghz->variable_item_list,
+            "Hopping:",
+            HOPPING_COUNT,
+            subghz_scene_receiver_config_set_hopping_running,
+            subghz);
+        value_index = subghz_scene_receiver_config_hopper_value_index(
+            subghz->txrx->hopper_state, hopping_value, HOPPING_COUNT, subghz);
+        variable_item_set_current_value_index(item, value_index);
+        variable_item_set_current_value_text(item, hopping_text[value_index]);
+    }
+
+    item = variable_item_list_add(
+        subghz->variable_item_list,
+        "Modulation:",
+        subghz_setting_get_preset_count(subghz->setting),
+        subghz_scene_receiver_config_set_preset,
+        subghz);
+    value_index = subghz_scene_receiver_config_next_preset(
+        string_get_cstr(subghz->txrx->preset->name), subghz);
+    variable_item_set_current_value_index(item, value_index);
+    variable_item_set_current_value_text(
+        item, subghz_setting_get_preset_name(subghz->setting, value_index));
+
+    if(scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneReadRAW) !=
+       SubGhzCustomEventManagerSet) {
+        variable_item_list_add(subghz->variable_item_list, "Lock Keyboard", 1, NULL, NULL);
+        variable_item_list_set_enter_callback(
+            subghz->variable_item_list,
+            subghz_scene_receiver_config_var_list_enter_callback,
+            subghz);
+    }
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdVariableItemList);
+}
+
+bool subghz_scene_receiver_config_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubGhzCustomEventSceneSettingLock) {
+            subghz->lock = SubGhzLockOn;
+            scene_manager_previous_scene(subghz->scene_manager);
+            consumed = true;
+        }
+    }
+    return consumed;
+}
+
+void subghz_scene_receiver_config_on_exit(void* context) {
+    SubGhz* subghz = context;
+    variable_item_list_reset(subghz->variable_item_list);
+    scene_manager_set_scene_state(
+        subghz->scene_manager, SubGhzSceneReadRAW, SubGhzCustomEventManagerNoSet);
+}
--- a/applications/main/subghz/scenes/subghz_scene_receiver_info.c
+++ b/applications/main/subghz/scenes/subghz_scene_receiver_info.c
@@ -0,0 +1,203 @@
+#include "../subghz_i.h"
+#include "../helpers/subghz_custom_event.h"
+#include <dolphin/dolphin.h>
+
+void subghz_scene_receiver_info_callback(GuiButtonType result, InputType type, void* context) {
+    furi_assert(context);
+    SubGhz* subghz = context;
+
+    if((result == GuiButtonTypeCenter) && (type == InputTypePress)) {
+        view_dispatcher_send_custom_event(
+            subghz->view_dispatcher, SubGhzCustomEventSceneReceiverInfoTxStart);
+    } else if((result == GuiButtonTypeCenter) && (type == InputTypeRelease)) {
+        view_dispatcher_send_custom_event(
+            subghz->view_dispatcher, SubGhzCustomEventSceneReceiverInfoTxStop);
+    } else if((result == GuiButtonTypeRight) && (type == InputTypeShort)) {
+        view_dispatcher_send_custom_event(
+            subghz->view_dispatcher, SubGhzCustomEventSceneReceiverInfoSave);
+    }
+}
+
+static bool subghz_scene_receiver_info_update_parser(void* context) {
+    SubGhz* subghz = context;
+    subghz->txrx->decoder_result = subghz_receiver_search_decoder_base_by_name(
+        subghz->txrx->receiver,
+        subghz_history_get_protocol_name(subghz->txrx->history, subghz->txrx->idx_menu_chosen));
+    if(subghz->txrx->decoder_result) {
+        subghz_protocol_decoder_base_deserialize(
+            subghz->txrx->decoder_result,
+            subghz_history_get_raw_data(subghz->txrx->history, subghz->txrx->idx_menu_chosen));
+
+        SubGhzPresetDefinition* preset =
+            subghz_history_get_preset_def(subghz->txrx->history, subghz->txrx->idx_menu_chosen);
+        subghz_preset_init(
+            subghz,
+            string_get_cstr(preset->name),
+            preset->frequency,
+            preset->data,
+            preset->data_size);
+
+        return true;
+    }
+    return false;
+}
+
+void subghz_scene_receiver_info_on_enter(void* context) {
+    SubGhz* subghz = context;
+
+    DOLPHIN_DEED(DolphinDeedSubGhzReceiverInfo);
+    if(subghz_scene_receiver_info_update_parser(subghz)) {
+        string_t frequency_str;
+        string_t modulation_str;
+        string_t text;
+
+        string_init(frequency_str);
+        string_init(modulation_str);
+        string_init(text);
+
+        subghz_get_frequency_modulation(subghz, frequency_str, modulation_str);
+        widget_add_string_element(
+            subghz->widget,
+            78,
+            0,
+            AlignLeft,
+            AlignTop,
+            FontSecondary,
+            string_get_cstr(frequency_str));
+
+        widget_add_string_element(
+            subghz->widget,
+            113,
+            0,
+            AlignLeft,
+            AlignTop,
+            FontSecondary,
+            string_get_cstr(modulation_str));
+        subghz_protocol_decoder_base_get_string(subghz->txrx->decoder_result, text);
+        widget_add_string_multiline_element(
+            subghz->widget, 0, 0, AlignLeft, AlignTop, FontSecondary, string_get_cstr(text));
+
+        string_clear(frequency_str);
+        string_clear(modulation_str);
+        string_clear(text);
+
+        if((subghz->txrx->decoder_result->protocol->flag & SubGhzProtocolFlag_Save) ==
+           SubGhzProtocolFlag_Save) {
+            widget_add_button_element(
+                subghz->widget,
+                GuiButtonTypeRight,
+                "Save",
+                subghz_scene_receiver_info_callback,
+                subghz);
+        }
+        if(((subghz->txrx->decoder_result->protocol->flag & SubGhzProtocolFlag_Send) ==
+            SubGhzProtocolFlag_Send) &&
+           subghz->txrx->decoder_result->protocol->encoder->deserialize &&
+           subghz->txrx->decoder_result->protocol->type == SubGhzProtocolTypeStatic) {
+            widget_add_button_element(
+                subghz->widget,
+                GuiButtonTypeCenter,
+                "Send",
+                subghz_scene_receiver_info_callback,
+                subghz);
+        }
+    } else {
+        widget_add_icon_element(subghz->widget, 37, 15, &I_DolphinCommon_56x48);
+        widget_add_string_element(
+            subghz->widget, 13, 8, AlignLeft, AlignBottom, FontSecondary, "Error history parse.");
+    }
+
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdWidget);
+}
+
+bool subghz_scene_receiver_info_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubGhzCustomEventSceneReceiverInfoTxStart) {
+            //CC1101 Stop RX -> Start TX
+            if(subghz->txrx->hopper_state != SubGhzHopperStateOFF) {
+                subghz->txrx->hopper_state = SubGhzHopperStatePause;
+            }
+            if(subghz->txrx->txrx_state == SubGhzTxRxStateRx) {
+                subghz_rx_end(subghz);
+            }
+            if(!subghz_scene_receiver_info_update_parser(subghz)) {
+                return false;
+            }
+            if(subghz->txrx->txrx_state == SubGhzTxRxStateIDLE ||
+               subghz->txrx->txrx_state == SubGhzTxRxStateSleep) {
+                if(!subghz_tx_start(
+                       subghz,
+                       subghz_history_get_raw_data(
+                           subghz->txrx->history, subghz->txrx->idx_menu_chosen))) {
+                    scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowOnlyRx);
+                } else {
+                    subghz->state_notifications = SubGhzNotificationStateTx;
+                }
+            }
+            return true;
+        } else if(event.event == SubGhzCustomEventSceneReceiverInfoTxStop) {
+            //CC1101 Stop Tx -> Start RX
+            subghz->state_notifications = SubGhzNotificationStateIDLE;
+            if(subghz->txrx->txrx_state == SubGhzTxRxStateTx) {
+                subghz_tx_stop(subghz);
+            }
+            if(subghz->txrx->txrx_state == SubGhzTxRxStateIDLE) {
+                subghz_begin(
+                    subghz,
+                    subghz_setting_get_preset_data_by_name(
+                        subghz->setting, string_get_cstr(subghz->txrx->preset->name)));
+                subghz_rx(subghz, subghz->txrx->preset->frequency);
+            }
+            if(subghz->txrx->hopper_state == SubGhzHopperStatePause) {
+                subghz->txrx->hopper_state = SubGhzHopperStateRunnig;
+            }
+            subghz->state_notifications = SubGhzNotificationStateRx;
+            return true;
+        } else if(event.event == SubGhzCustomEventSceneReceiverInfoSave) {
+            //CC1101 Stop RX -> Save
+            subghz->state_notifications = SubGhzNotificationStateIDLE;
+            if(subghz->txrx->hopper_state != SubGhzHopperStateOFF) {
+                subghz->txrx->hopper_state = SubGhzHopperStateOFF;
+            }
+            if(subghz->txrx->txrx_state == SubGhzTxRxStateRx) {
+                subghz_rx_end(subghz);
+                subghz_sleep(subghz);
+            }
+            if(!subghz_scene_receiver_info_update_parser(subghz)) {
+                return false;
+            }
+
+            if((subghz->txrx->decoder_result->protocol->flag & SubGhzProtocolFlag_Save) ==
+               SubGhzProtocolFlag_Save) {
+                subghz_file_name_clear(subghz);
+                scene_manager_next_scene(subghz->scene_manager, SubGhzSceneSaveName);
+            }
+            return true;
+        }
+    } else if(event.type == SceneManagerEventTypeTick) {
+        if(subghz->txrx->hopper_state != SubGhzHopperStateOFF) {
+            subghz_hopper_update(subghz);
+        }
+        switch(subghz->state_notifications) {
+        case SubGhzNotificationStateTx:
+            notification_message(subghz->notifications, &sequence_blink_magenta_10);
+            break;
+        case SubGhzNotificationStateRx:
+            notification_message(subghz->notifications, &sequence_blink_cyan_10);
+            break;
+        case SubGhzNotificationStateRxDone:
+            notification_message(subghz->notifications, &sequence_blink_green_100);
+            subghz->state_notifications = SubGhzNotificationStateRx;
+            break;
+        default:
+            break;
+        }
+    }
+    return false;
+}
+
+void subghz_scene_receiver_info_on_exit(void* context) {
+    SubGhz* subghz = context;
+    widget_reset(subghz->widget);
+}
--- a/applications/main/subghz/scenes/subghz_scene_rpc.c
+++ b/applications/main/subghz/scenes/subghz_scene_rpc.c
@@ -0,0 +1,100 @@
+#include "../subghz_i.h"
+
+typedef enum {
+    SubGhzRpcStateIdle,
+    SubGhzRpcStateLoaded,
+} SubGhzRpcState;
+
+void subghz_scene_rpc_on_enter(void* context) {
+    SubGhz* subghz = context;
+    Popup* popup = subghz->popup;
+
+    popup_set_header(popup, "Sub-GHz", 89, 42, AlignCenter, AlignBottom);
+    popup_set_text(popup, "RPC mode", 89, 44, AlignCenter, AlignTop);
+
+    popup_set_icon(popup, 0, 12, &I_RFIDDolphinSend_97x61);
+
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdPopup);
+
+    scene_manager_set_scene_state(subghz->scene_manager, SubGhzSceneRpc, SubGhzRpcStateIdle);
+
+    notification_message(subghz->notifications, &sequence_display_backlight_on);
+}
+
+bool subghz_scene_rpc_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+    Popup* popup = subghz->popup;
+    bool consumed = false;
+    SubGhzRpcState state = scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneRpc);
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        consumed = true;
+        if(event.event == SubGhzCustomEventSceneExit) {
+            scene_manager_stop(subghz->scene_manager);
+            view_dispatcher_stop(subghz->view_dispatcher);
+            rpc_system_app_confirm(subghz->rpc_ctx, RpcAppEventAppExit, true);
+        } else if(event.event == SubGhzCustomEventSceneRpcSessionClose) {
+            scene_manager_stop(subghz->scene_manager);
+            view_dispatcher_stop(subghz->view_dispatcher);
+        } else if(event.event == SubGhzCustomEventSceneRpcButtonPress) {
+            bool result = false;
+            if((subghz->txrx->txrx_state == SubGhzTxRxStateSleep) &&
+               (state == SubGhzRpcStateLoaded)) {
+                subghz_blink_start(subghz);
+                result = subghz_tx_start(subghz, subghz->txrx->fff_data);
+                result = true;
+            }
+            rpc_system_app_confirm(subghz->rpc_ctx, RpcAppEventButtonPress, result);
+        } else if(event.event == SubGhzCustomEventSceneRpcButtonRelease) {
+            bool result = false;
+            if(subghz->txrx->txrx_state == SubGhzTxRxStateTx) {
+                subghz_blink_stop(subghz);
+                subghz_tx_stop(subghz);
+                subghz_sleep(subghz);
+                result = true;
+            }
+            rpc_system_app_confirm(subghz->rpc_ctx, RpcAppEventButtonRelease, result);
+        } else if(event.event == SubGhzCustomEventSceneRpcLoad) {
+            bool result = false;
+            const char* arg = rpc_system_app_get_data(subghz->rpc_ctx);
+            if(arg && (state == SubGhzRpcStateIdle)) {
+                if(subghz_key_load(subghz, arg, false)) {
+                    scene_manager_set_scene_state(
+                        subghz->scene_manager, SubGhzSceneRpc, SubGhzRpcStateLoaded);
+                    string_set_str(subghz->file_path, arg);
+                    result = true;
+                    string_t file_name;
+                    string_init(file_name);
+                    path_extract_filename(subghz->file_path, file_name, true);
+
+                    snprintf(
+                        subghz->file_name_tmp,
+                        SUBGHZ_MAX_LEN_NAME,
+                        "loaded\n%s",
+                        string_get_cstr(file_name));
+                    popup_set_text(popup, subghz->file_name_tmp, 89, 44, AlignCenter, AlignTop);
+
+                    string_clear(file_name);
+                }
+            }
+            rpc_system_app_confirm(subghz->rpc_ctx, RpcAppEventLoadFile, result);
+        }
+    }
+    return consumed;
+}
+
+void subghz_scene_rpc_on_exit(void* context) {
+    SubGhz* subghz = context;
+
+    if(subghz->txrx->txrx_state == SubGhzTxRxStateTx) {
+        subghz_tx_stop(subghz);
+        subghz_sleep(subghz);
+        subghz_blink_stop(subghz);
+    }
+
+    Popup* popup = subghz->popup;
+
+    popup_set_header(popup, NULL, 0, 0, AlignCenter, AlignBottom);
+    popup_set_text(popup, NULL, 0, 0, AlignCenter, AlignTop);
+    popup_set_icon(popup, 0, 0, NULL);
+}
--- a/applications/main/subghz/scenes/subghz_scene_save_name.c
+++ b/applications/main/subghz/scenes/subghz_scene_save_name.c
@@ -0,0 +1,141 @@
+#include "../subghz_i.h"
+#include "m-string.h"
+#include "subghz/types.h"
+#include <lib/toolbox/random_name.h>
+#include "../helpers/subghz_custom_event.h"
+#include <lib/subghz/protocols/raw.h>
+#include <gui/modules/validators.h>
+
+#define MAX_TEXT_INPUT_LEN 22
+
+void subghz_scene_save_name_text_input_callback(void* context) {
+    furi_assert(context);
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, SubGhzCustomEventSceneSaveName);
+}
+
+void subghz_scene_save_name_on_enter(void* context) {
+    SubGhz* subghz = context;
+
+    // Setup view
+    TextInput* text_input = subghz->text_input;
+    bool dev_name_empty = false;
+
+    string_t file_name;
+    string_t dir_name;
+    string_init(file_name);
+    string_init(dir_name);
+
+    if(!subghz_path_is_file(subghz->file_path)) {
+        char file_name_buf[SUBGHZ_MAX_LEN_NAME] = {0};
+        set_random_name(file_name_buf, SUBGHZ_MAX_LEN_NAME);
+        string_set_str(file_name, file_name_buf);
+        string_set_str(subghz->file_path, SUBGHZ_APP_FOLDER);
+        //highlighting the entire filename by default
+        dev_name_empty = true;
+    } else {
+        string_set(subghz->file_path_tmp, subghz->file_path);
+        path_extract_dirname(string_get_cstr(subghz->file_path), dir_name);
+        path_extract_filename(subghz->file_path, file_name, true);
+        if(scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneReadRAW) !=
+           SubGhzCustomEventManagerNoSet) {
+            if(scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneReadRAW) ==
+               SubGhzCustomEventManagerSetRAW) {
+                dev_name_empty = true;
+                subghz_get_next_name_file(subghz, SUBGHZ_MAX_LEN_NAME);
+            }
+            path_extract_filename(subghz->file_path, file_name, true);
+        }
+        string_set(subghz->file_path, dir_name);
+    }
+
+    strncpy(subghz->file_name_tmp, string_get_cstr(file_name), SUBGHZ_MAX_LEN_NAME);
+    text_input_set_header_text(text_input, "Name signal");
+    text_input_set_result_callback(
+        text_input,
+        subghz_scene_save_name_text_input_callback,
+        subghz,
+        subghz->file_name_tmp,
+        MAX_TEXT_INPUT_LEN, // buffer size
+        dev_name_empty);
+
+    ValidatorIsFile* validator_is_file =
+        validator_is_file_alloc_init(string_get_cstr(subghz->file_path), SUBGHZ_APP_EXTENSION, "");
+    text_input_set_validator(text_input, validator_is_file_callback, validator_is_file);
+
+    string_clear(file_name);
+    string_clear(dir_name);
+
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdTextInput);
+}
+
+bool subghz_scene_save_name_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+    if(event.type == SceneManagerEventTypeBack) {
+        if(!strcmp(subghz->file_name_tmp, "") ||
+           scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneReadRAW) !=
+               SubGhzCustomEventManagerNoSet) {
+            string_set(subghz->file_path, subghz->file_path_tmp);
+        }
+        scene_manager_previous_scene(subghz->scene_manager);
+        return true;
+    } else if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubGhzCustomEventSceneSaveName) {
+            if(strcmp(subghz->file_name_tmp, "")) {
+                string_cat_printf(
+                    subghz->file_path, "/%s%s", subghz->file_name_tmp, SUBGHZ_APP_EXTENSION);
+                if(subghz_path_is_file(subghz->file_path_tmp)) {
+                    if(!subghz_rename_file(subghz)) {
+                        return false;
+                    }
+                } else {
+                    if(scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneSetType) !=
+                       SubGhzCustomEventManagerNoSet) {
+                        subghz_save_protocol_to_file(
+                            subghz, subghz->txrx->fff_data, string_get_cstr(subghz->file_path));
+                        scene_manager_set_scene_state(
+                            subghz->scene_manager,
+                            SubGhzSceneSetType,
+                            SubGhzCustomEventManagerNoSet);
+                    } else {
+                        subghz_save_protocol_to_file(
+                            subghz,
+                            subghz_history_get_raw_data(
+                                subghz->txrx->history, subghz->txrx->idx_menu_chosen),
+                            string_get_cstr(subghz->file_path));
+                    }
+                }
+
+                if(scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneReadRAW) !=
+                   SubGhzCustomEventManagerNoSet) {
+                    subghz_protocol_raw_gen_fff_data(
+                        subghz->txrx->fff_data, string_get_cstr(subghz->file_path));
+                    scene_manager_set_scene_state(
+                        subghz->scene_manager, SubGhzSceneReadRAW, SubGhzCustomEventManagerNoSet);
+                } else {
+                    subghz_file_name_clear(subghz);
+                }
+
+                scene_manager_next_scene(subghz->scene_manager, SubGhzSceneSaveSuccess);
+                return true;
+            } else {
+                string_set_str(subghz->error_str, "No name file");
+                scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowErrorSub);
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+void subghz_scene_save_name_on_exit(void* context) {
+    SubGhz* subghz = context;
+
+    // Clear validator
+    void* validator_context = text_input_get_validator_callback_context(subghz->text_input);
+    text_input_set_validator(subghz->text_input, NULL, NULL);
+    validator_is_file_free(validator_context);
+
+    // Clear view
+    text_input_reset(subghz->text_input);
+}
--- a/applications/main/subghz/scenes/subghz_scene_save_success.c
+++ b/applications/main/subghz/scenes/subghz_scene_save_success.c
@@ -0,0 +1,60 @@
+#include "../subghz_i.h"
+#include "../helpers/subghz_custom_event.h"
+#include <dolphin/helpers/dolphin_deed.h>
+#include <dolphin/dolphin.h>
+
+void subghz_scene_save_success_popup_callback(void* context) {
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, SubGhzCustomEventSceneSaveSuccess);
+}
+
+void subghz_scene_save_success_on_enter(void* context) {
+    SubGhz* subghz = context;
+    DOLPHIN_DEED(DolphinDeedSubGhzSave);
+
+    // Setup view
+    Popup* popup = subghz->popup;
+    popup_set_icon(popup, 32, 5, &I_DolphinNice_96x59);
+    popup_set_header(popup, "Saved!", 13, 22, AlignLeft, AlignBottom);
+    popup_set_timeout(popup, 1500);
+    popup_set_context(popup, subghz);
+    popup_set_callback(popup, subghz_scene_save_success_popup_callback);
+    popup_enable_timeout(popup);
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdPopup);
+}
+
+bool subghz_scene_save_success_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubGhzCustomEventSceneSaveSuccess) {
+            if(!scene_manager_search_and_switch_to_previous_scene(
+                   subghz->scene_manager, SubGhzSceneReceiver)) {
+                subghz->txrx->rx_key_state = SubGhzRxKeyStateRAWSave;
+                if(!scene_manager_search_and_switch_to_previous_scene(
+                       subghz->scene_manager, SubGhzSceneReadRAW)) {
+                    subghz->txrx->rx_key_state = SubGhzRxKeyStateIDLE;
+                    if(!scene_manager_search_and_switch_to_previous_scene(
+                           subghz->scene_manager, SubGhzSceneSaved)) {
+                        scene_manager_next_scene(subghz->scene_manager, SubGhzSceneSaved);
+                    }
+                }
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
+void subghz_scene_save_success_on_exit(void* context) {
+    SubGhz* subghz = context;
+
+    // Clear view
+    Popup* popup = subghz->popup;
+    popup_set_header(popup, NULL, 0, 0, AlignCenter, AlignBottom);
+    popup_set_text(popup, NULL, 0, 0, AlignCenter, AlignTop);
+    popup_set_icon(popup, 0, 0, NULL);
+    popup_set_callback(popup, NULL);
+    popup_set_context(popup, NULL);
+    popup_set_timeout(popup, 0);
+    popup_disable_timeout(popup);
+}
--- a/applications/main/subghz/scenes/subghz_scene_saved.c
+++ b/applications/main/subghz/scenes/subghz_scene_saved.c
@@ -0,0 +1,26 @@
+#include "../subghz_i.h"
+
+void subghz_scene_saved_on_enter(void* context) {
+    SubGhz* subghz = context;
+
+    if(subghz_load_protocol_from_file(subghz)) {
+        if((!strcmp(subghz->txrx->decoder_result->protocol->name, "RAW"))) {
+            subghz->txrx->rx_key_state = SubGhzRxKeyStateRAWLoad;
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneReadRAW);
+        } else {
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneSavedMenu);
+        }
+    } else {
+        scene_manager_search_and_switch_to_previous_scene(subghz->scene_manager, SubGhzSceneStart);
+    }
+}
+
+bool subghz_scene_saved_on_event(void* context, SceneManagerEvent event) {
+    UNUSED(context);
+    UNUSED(event);
+    return false;
+}
+
+void subghz_scene_saved_on_exit(void* context) {
+    UNUSED(context);
+}
--- a/applications/main/subghz/scenes/subghz_scene_saved_menu.c
+++ b/applications/main/subghz/scenes/subghz_scene_saved_menu.c
@@ -0,0 +1,71 @@
+#include "../subghz_i.h"
+
+enum SubmenuIndex {
+    SubmenuIndexEmulate,
+    SubmenuIndexEdit,
+    SubmenuIndexDelete,
+};
+
+void subghz_scene_saved_menu_submenu_callback(void* context, uint32_t index) {
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, index);
+}
+
+void subghz_scene_saved_menu_on_enter(void* context) {
+    SubGhz* subghz = context;
+    submenu_add_item(
+        subghz->submenu,
+        "Emulate",
+        SubmenuIndexEmulate,
+        subghz_scene_saved_menu_submenu_callback,
+        subghz);
+
+    submenu_add_item(
+        subghz->submenu,
+        "Rename",
+        SubmenuIndexEdit,
+        subghz_scene_saved_menu_submenu_callback,
+        subghz);
+
+    submenu_add_item(
+        subghz->submenu,
+        "Delete",
+        SubmenuIndexDelete,
+        subghz_scene_saved_menu_submenu_callback,
+        subghz);
+
+    submenu_set_selected_item(
+        subghz->submenu,
+        scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneSavedMenu));
+
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdMenu);
+}
+
+bool subghz_scene_saved_menu_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubmenuIndexEmulate) {
+            scene_manager_set_scene_state(
+                subghz->scene_manager, SubGhzSceneSavedMenu, SubmenuIndexEmulate);
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneTransmitter);
+            return true;
+        } else if(event.event == SubmenuIndexDelete) {
+            scene_manager_set_scene_state(
+                subghz->scene_manager, SubGhzSceneSavedMenu, SubmenuIndexDelete);
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneDelete);
+            return true;
+        } else if(event.event == SubmenuIndexEdit) {
+            scene_manager_set_scene_state(
+                subghz->scene_manager, SubGhzSceneSavedMenu, SubmenuIndexEdit);
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneSaveName);
+            return true;
+        }
+    }
+    return false;
+}
+
+void subghz_scene_saved_menu_on_exit(void* context) {
+    SubGhz* subghz = context;
+    submenu_reset(subghz->submenu);
+}
--- a/applications/main/subghz/scenes/subghz_scene_set_type.c
+++ b/applications/main/subghz/scenes/subghz_scene_set_type.c
@@ -0,0 +1,396 @@
+#include "../subghz_i.h"
+#include <lib/subghz/protocols/keeloq.h>
+#include <lib/subghz/protocols/secplus_v1.h>
+#include <lib/subghz/protocols/secplus_v2.h>
+#include <lib/subghz/blocks/math.h>
+#include <dolphin/dolphin.h>
+#include <flipper_format/flipper_format_i.h>
+#include <lib/toolbox/stream/stream.h>
+#include <lib/subghz/protocols/registry.h>
+
+#define TAG "SubGhzSetType"
+
+bool subghz_scene_set_type_submenu_gen_data_protocol(
+    void* context,
+    const char* protocol_name,
+    uint64_t key,
+    uint32_t bit,
+    uint32_t frequency,
+    const char* preset_name) {
+    furi_assert(context);
+    SubGhz* subghz = context;
+
+    bool res = false;
+
+    subghz_preset_init(subghz, preset_name, frequency, NULL, 0);
+    subghz->txrx->decoder_result =
+        subghz_receiver_search_decoder_base_by_name(subghz->txrx->receiver, protocol_name);
+
+    if(subghz->txrx->decoder_result == NULL) {
+        string_set_str(subghz->error_str, "Protocol not\nfound!");
+        scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowErrorSub);
+        return false;
+    }
+
+    do {
+        Stream* fff_data_stream = flipper_format_get_raw_stream(subghz->txrx->fff_data);
+        stream_clean(fff_data_stream);
+        if(!subghz_protocol_decoder_base_serialize(
+               subghz->txrx->decoder_result, subghz->txrx->fff_data, subghz->txrx->preset)) {
+            FURI_LOG_E(TAG, "Unable to serialize");
+            break;
+        }
+        if(!flipper_format_update_uint32(subghz->txrx->fff_data, "Bit", &bit, 1)) {
+            FURI_LOG_E(TAG, "Unable to update Bit");
+            break;
+        }
+
+        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] = (key >> i * 8) & 0xFF;
+        }
+        if(!flipper_format_update_hex(subghz->txrx->fff_data, "Key", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to update Key");
+            break;
+        }
+        res = true;
+    } while(false);
+    return res;
+}
+
+void subghz_scene_set_type_submenu_callback(void* context, uint32_t index) {
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, index);
+}
+
+void subghz_scene_set_type_on_enter(void* context) {
+    SubGhz* subghz = context;
+
+    submenu_add_item(
+        subghz->submenu,
+        "Princeton_433",
+        SubmenuIndexPricenton,
+        subghz_scene_set_type_submenu_callback,
+        subghz);
+    submenu_add_item(
+        subghz->submenu,
+        "Nice Flo 12bit_433",
+        SubmenuIndexNiceFlo12bit,
+        subghz_scene_set_type_submenu_callback,
+        subghz);
+    submenu_add_item(
+        subghz->submenu,
+        "Nice Flo 24bit_433",
+        SubmenuIndexNiceFlo24bit,
+        subghz_scene_set_type_submenu_callback,
+        subghz);
+    submenu_add_item(
+        subghz->submenu,
+        "CAME 12bit_433",
+        SubmenuIndexCAME12bit,
+        subghz_scene_set_type_submenu_callback,
+        subghz);
+    submenu_add_item(
+        subghz->submenu,
+        "CAME 24bit_433",
+        SubmenuIndexCAME24bit,
+        subghz_scene_set_type_submenu_callback,
+        subghz);
+    submenu_add_item(
+        subghz->submenu,
+        "Linear_300",
+        SubmenuIndexLinear_300_00,
+        subghz_scene_set_type_submenu_callback,
+        subghz);
+    submenu_add_item(
+        subghz->submenu,
+        "CAME TWEE",
+        SubmenuIndexCAMETwee,
+        subghz_scene_set_type_submenu_callback,
+        subghz);
+    // submenu_add_item(
+    //     subghz->submenu, "Nero Sketch", SubmenuIndexNeroSketch, subghz_scene_set_type_submenu_callback, subghz);
+    // submenu_add_item(
+    //     subghz->submenu, "Nero Radio", SubmenuIndexNeroRadio, subghz_scene_set_type_submenu_callback, subghz);
+    submenu_add_item(
+        subghz->submenu,
+        "Gate TX_433",
+        SubmenuIndexGateTX,
+        subghz_scene_set_type_submenu_callback,
+        subghz);
+    submenu_add_item(
+        subghz->submenu,
+        "DoorHan_315",
+        SubmenuIndexDoorHan_315_00,
+        subghz_scene_set_type_submenu_callback,
+        subghz);
+    submenu_add_item(
+        subghz->submenu,
+        "DoorHan_433",
+        SubmenuIndexDoorHan_433_92,
+        subghz_scene_set_type_submenu_callback,
+        subghz);
+    submenu_add_item(
+        subghz->submenu,
+        "LiftMaster_315",
+        SubmenuIndexLiftMaster_315_00,
+        subghz_scene_set_type_submenu_callback,
+        subghz);
+    submenu_add_item(
+        subghz->submenu,
+        "LiftMaster_390",
+        SubmenuIndexLiftMaster_390_00,
+        subghz_scene_set_type_submenu_callback,
+        subghz);
+    submenu_add_item(
+        subghz->submenu,
+        "Security+2.0_310",
+        SubmenuIndexSecPlus_v2_310_00,
+        subghz_scene_set_type_submenu_callback,
+        subghz);
+    submenu_add_item(
+        subghz->submenu,
+        "Security+2.0_315",
+        SubmenuIndexSecPlus_v2_315_00,
+        subghz_scene_set_type_submenu_callback,
+        subghz);
+    submenu_add_item(
+        subghz->submenu,
+        "Security+2.0_390",
+        SubmenuIndexSecPlus_v2_390_00,
+        subghz_scene_set_type_submenu_callback,
+        subghz);
+
+    submenu_set_selected_item(
+        subghz->submenu, scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneSetType));
+
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdMenu);
+}
+
+bool subghz_scene_set_type_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+    bool generated_protocol = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        //ToDo Fix
+        uint32_t key = subghz_random_serial();
+        switch(event.event) {
+        case SubmenuIndexPricenton:
+            key = (key & 0x00FFFFF0) | 0x4; //btn 0x1, 0x2, 0x4, 0x8
+            if(subghz_scene_set_type_submenu_gen_data_protocol(
+                   subghz, SUBGHZ_PROTOCOL_PRINCETON_NAME, key, 24, 433920000, "AM650")) {
+                uint32_t te = 400;
+                flipper_format_update_uint32(subghz->txrx->fff_data, "TE", (uint32_t*)&te, 1);
+                generated_protocol = true;
+            }
+            break;
+        case SubmenuIndexNiceFlo12bit:
+            key = (key & 0x0000FFF0) | 0x1; //btn 0x1, 0x2, 0x4
+            if(subghz_scene_set_type_submenu_gen_data_protocol(
+                   subghz, SUBGHZ_PROTOCOL_NICE_FLO_NAME, key, 12, 433920000, "AM650")) {
+                generated_protocol = true;
+            }
+            break;
+        case SubmenuIndexNiceFlo24bit:
+            key = (key & 0x00FFFFF0) | 0x4; //btn 0x1, 0x2, 0x4, 0x8
+            if(subghz_scene_set_type_submenu_gen_data_protocol(
+                   subghz, SUBGHZ_PROTOCOL_NICE_FLO_NAME, key, 24, 433920000, "AM650")) {
+                generated_protocol = true;
+            }
+            break;
+        case SubmenuIndexCAME12bit:
+            key = (key & 0x0000FFF0) | 0x1; //btn 0x1, 0x2, 0x4
+            if(subghz_scene_set_type_submenu_gen_data_protocol(
+                   subghz, SUBGHZ_PROTOCOL_CAME_NAME, key, 12, 433920000, "AM650")) {
+                generated_protocol = true;
+            }
+            break;
+        case SubmenuIndexCAME24bit:
+            key = (key & 0x00FFFFF0) | 0x4; //btn 0x1, 0x2, 0x4, 0x8
+            if(subghz_scene_set_type_submenu_gen_data_protocol(
+                   subghz, SUBGHZ_PROTOCOL_CAME_NAME, key, 24, 433920000, "AM650")) {
+                generated_protocol = true;
+            }
+            break;
+        case SubmenuIndexLinear_300_00:
+            key = (key & 0x3FF);
+            if(subghz_scene_set_type_submenu_gen_data_protocol(
+                   subghz, SUBGHZ_PROTOCOL_LINEAR_NAME, key, 10, 300000000, "AM650")) {
+                generated_protocol = true;
+            }
+            break;
+        case SubmenuIndexCAMETwee:
+            key = (key & 0x0FFFFFF0);
+            key = 0x003FFF7200000000 | (key ^ 0xE0E0E0EE);
+            if(subghz_scene_set_type_submenu_gen_data_protocol(
+                   subghz, SUBGHZ_PROTOCOL_CAME_TWEE_NAME, key, 54, 433920000, "AM650")) {
+                generated_protocol = true;
+            }
+            break;
+        // case SubmenuIndexNeroSketch:
+        //     /* code */
+        //     break;
+        // case SubmenuIndexNeroRadio:
+        //     /* code */
+        //     break;
+        case SubmenuIndexGateTX:
+            key = (key & 0x00F0FF00) | 0xF << 16 | 0x40; //btn 0xF, 0xC, 0xA, 0x6 (?)
+            uint64_t rev_key = subghz_protocol_blocks_reverse_key(key, 24);
+            if(subghz_scene_set_type_submenu_gen_data_protocol(
+                   subghz, SUBGHZ_PROTOCOL_GATE_TX_NAME, rev_key, 24, 433920000, "AM650")) {
+                generated_protocol = true;
+            }
+            break;
+        case SubmenuIndexDoorHan_433_92:
+            subghz->txrx->transmitter = subghz_transmitter_alloc_init(
+                subghz->txrx->environment, SUBGHZ_PROTOCOL_KEELOQ_NAME);
+            subghz_preset_init(
+                subghz, "AM650", subghz_setting_get_default_frequency(subghz->setting), NULL, 0);
+            if(subghz->txrx->transmitter) {
+                subghz_protocol_keeloq_create_data(
+                    subghz_transmitter_get_protocol_instance(subghz->txrx->transmitter),
+                    subghz->txrx->fff_data,
+                    key & 0x0FFFFFFF,
+                    0x2,
+                    0x0003,
+                    "DoorHan",
+                    subghz->txrx->preset);
+                generated_protocol = true;
+            } else {
+                generated_protocol = false;
+            }
+            subghz_transmitter_free(subghz->txrx->transmitter);
+            if(!generated_protocol) {
+                string_set_str(
+                    subghz->error_str, "Function requires\nan SD card with\nfresh databases.");
+                scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowError);
+            }
+            break;
+        case SubmenuIndexDoorHan_315_00:
+            subghz->txrx->transmitter = subghz_transmitter_alloc_init(
+                subghz->txrx->environment, SUBGHZ_PROTOCOL_KEELOQ_NAME);
+            subghz_preset_init(subghz, "AM650", 315000000, NULL, 0);
+            if(subghz->txrx->transmitter) {
+                subghz_protocol_keeloq_create_data(
+                    subghz_transmitter_get_protocol_instance(subghz->txrx->transmitter),
+                    subghz->txrx->fff_data,
+                    key & 0x0FFFFFFF,
+                    0x2,
+                    0x0003,
+                    "DoorHan",
+                    subghz->txrx->preset);
+                generated_protocol = true;
+            } else {
+                generated_protocol = false;
+            }
+            subghz_transmitter_free(subghz->txrx->transmitter);
+            if(!generated_protocol) {
+                string_set_str(
+                    subghz->error_str, "Function requires\nan SD card with\nfresh databases.");
+                scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowError);
+            }
+            break;
+        case SubmenuIndexLiftMaster_315_00:
+            while(!subghz_protocol_secplus_v1_check_fixed(key)) {
+                key = subghz_random_serial();
+            }
+            if(subghz_scene_set_type_submenu_gen_data_protocol(
+                   subghz,
+                   SUBGHZ_PROTOCOL_SECPLUS_V1_NAME,
+                   (uint64_t)key << 32 | 0xE6000000,
+                   42,
+                   315000000,
+                   "AM650")) {
+                generated_protocol = true;
+            }
+            break;
+        case SubmenuIndexLiftMaster_390_00:
+            while(!subghz_protocol_secplus_v1_check_fixed(key)) {
+                key = subghz_random_serial();
+            }
+            if(subghz_scene_set_type_submenu_gen_data_protocol(
+                   subghz,
+                   SUBGHZ_PROTOCOL_SECPLUS_V1_NAME,
+                   (uint64_t)key << 32 | 0xE6000000,
+                   42,
+                   390000000,
+                   "AM650")) {
+                generated_protocol = true;
+            }
+            break;
+        case SubmenuIndexSecPlus_v2_310_00:
+            subghz->txrx->transmitter = subghz_transmitter_alloc_init(
+                subghz->txrx->environment, SUBGHZ_PROTOCOL_SECPLUS_V2_NAME);
+            subghz_preset_init(subghz, "AM650", 310000000, NULL, 0);
+            if(subghz->txrx->transmitter) {
+                subghz_protocol_secplus_v2_create_data(
+                    subghz_transmitter_get_protocol_instance(subghz->txrx->transmitter),
+                    subghz->txrx->fff_data,
+                    key,
+                    0x68,
+                    0xE500000,
+                    subghz->txrx->preset);
+                generated_protocol = true;
+            } else {
+                generated_protocol = false;
+            }
+            subghz_transmitter_free(subghz->txrx->transmitter);
+            break;
+        case SubmenuIndexSecPlus_v2_315_00:
+            subghz->txrx->transmitter = subghz_transmitter_alloc_init(
+                subghz->txrx->environment, SUBGHZ_PROTOCOL_SECPLUS_V2_NAME);
+            subghz_preset_init(subghz, "AM650", 315000000, NULL, 0);
+            if(subghz->txrx->transmitter) {
+                subghz_protocol_secplus_v2_create_data(
+                    subghz_transmitter_get_protocol_instance(subghz->txrx->transmitter),
+                    subghz->txrx->fff_data,
+                    key,
+                    0x68,
+                    0xE500000,
+                    subghz->txrx->preset);
+                generated_protocol = true;
+            } else {
+                generated_protocol = false;
+            }
+            subghz_transmitter_free(subghz->txrx->transmitter);
+            break;
+        case SubmenuIndexSecPlus_v2_390_00:
+            subghz->txrx->transmitter = subghz_transmitter_alloc_init(
+                subghz->txrx->environment, SUBGHZ_PROTOCOL_SECPLUS_V2_NAME);
+            subghz_preset_init(subghz, "AM650", 390000000, NULL, 0);
+            if(subghz->txrx->transmitter) {
+                subghz_protocol_secplus_v2_create_data(
+                    subghz_transmitter_get_protocol_instance(subghz->txrx->transmitter),
+                    subghz->txrx->fff_data,
+                    key,
+                    0x68,
+                    0xE500000,
+                    subghz->txrx->preset);
+                generated_protocol = true;
+            } else {
+                generated_protocol = false;
+            }
+            subghz_transmitter_free(subghz->txrx->transmitter);
+            break;
+        default:
+            return false;
+            break;
+        }
+
+        scene_manager_set_scene_state(subghz->scene_manager, SubGhzSceneSetType, event.event);
+
+        if(generated_protocol) {
+            subghz_file_name_clear(subghz);
+            DOLPHIN_DEED(DolphinDeedSubGhzAddManually);
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneSaveName);
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void subghz_scene_set_type_on_exit(void* context) {
+    SubGhz* subghz = context;
+    submenu_reset(subghz->submenu);
+}
--- a/applications/main/subghz/scenes/subghz_scene_show_error.c
+++ b/applications/main/subghz/scenes/subghz_scene_show_error.c
@@ -0,0 +1,94 @@
+#include "../subghz_i.h"
+#include "../helpers/subghz_custom_event.h"
+
+static const NotificationSequence subghs_sequence_sd_error = {
+    &message_red_255,
+    &message_green_255,
+    &message_do_not_reset,
+    NULL,
+};
+
+void subghz_scene_show_error_callback(GuiButtonType result, InputType type, void* context) {
+    furi_assert(context);
+    SubGhz* subghz = context;
+
+    if((result == GuiButtonTypeRight) && (type == InputTypeShort)) {
+        view_dispatcher_send_custom_event(
+            subghz->view_dispatcher, SubGhzCustomEventSceneShowErrorOk);
+    } else if((result == GuiButtonTypeLeft) && (type == InputTypeShort)) {
+        view_dispatcher_send_custom_event(
+            subghz->view_dispatcher, SubGhzCustomEventSceneShowErrorBack);
+    }
+}
+
+void subghz_scene_show_error_on_enter(void* context) {
+    SubGhz* subghz = context;
+
+    widget_add_icon_element(subghz->widget, 0, 0, &I_SDQuestion_35x43);
+
+    widget_add_string_multiline_element(
+        subghz->widget,
+        81,
+        24,
+        AlignCenter,
+        AlignCenter,
+        FontSecondary,
+        string_get_cstr(subghz->error_str));
+    if(scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneShowError) ==
+       SubGhzCustomEventManagerSet) {
+        widget_add_button_element(
+            subghz->widget, GuiButtonTypeRight, "OK", subghz_scene_show_error_callback, subghz);
+    } else {
+        notification_message(subghz->notifications, &subghs_sequence_sd_error);
+    }
+
+    widget_add_button_element(
+        subghz->widget, GuiButtonTypeLeft, "Back", subghz_scene_show_error_callback, subghz);
+
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdWidget);
+}
+
+bool subghz_scene_show_error_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+    if(event.type == SceneManagerEventTypeBack) {
+        if(scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneShowError) ==
+           SubGhzCustomEventManagerSet) {
+            return false;
+        } else {
+            scene_manager_search_and_switch_to_previous_scene(
+                subghz->scene_manager, SubGhzSceneStart);
+        }
+        return true;
+    } else if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubGhzCustomEventSceneShowErrorOk) {
+            if(scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneShowError) ==
+               SubGhzCustomEventManagerSet) {
+                scene_manager_next_scene(subghz->scene_manager, SubGhzSceneStart);
+            }
+            return true;
+        } else if(event.event == SubGhzCustomEventSceneShowErrorBack) {
+            if(scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneShowError) ==
+               SubGhzCustomEventManagerSet) {
+                //exit app
+                if(!scene_manager_previous_scene(subghz->scene_manager)) {
+                    scene_manager_stop(subghz->scene_manager);
+                    view_dispatcher_stop(subghz->view_dispatcher);
+                }
+            } else {
+                scene_manager_search_and_switch_to_previous_scene(
+                    subghz->scene_manager, SubGhzSceneStart);
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
+void subghz_scene_show_error_on_exit(void* context) {
+    SubGhz* subghz = context;
+    scene_manager_set_scene_state(
+        subghz->scene_manager, SubGhzSceneShowError, SubGhzCustomEventManagerNoSet);
+    widget_reset(subghz->widget);
+    string_reset(subghz->error_str);
+    notification_message(subghz->notifications, &sequence_reset_rgb);
+}
--- a/applications/main/subghz/scenes/subghz_scene_show_error_sub.c
+++ b/applications/main/subghz/scenes/subghz_scene_show_error_sub.c
@@ -0,0 +1,52 @@
+#include "../subghz_i.h"
+#include "../helpers/subghz_custom_event.h"
+
+void subghz_scene_show_error_sub_popup_callback(void* context) {
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, SubGhzCustomEventSceneShowErrorSub);
+}
+
+void subghz_scene_show_error_sub_on_enter(void* context) {
+    SubGhz* subghz = context;
+
+    // Setup view
+    Popup* popup = subghz->popup;
+    popup_set_icon(popup, 72, 17, &I_DolphinCommon_56x48);
+    popup_set_header(popup, string_get_cstr(subghz->error_str), 14, 15, AlignLeft, AlignTop);
+    popup_set_timeout(popup, 1500);
+    popup_set_context(popup, subghz);
+    popup_set_callback(popup, subghz_scene_show_error_sub_popup_callback);
+    popup_enable_timeout(popup);
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdPopup);
+
+    notification_message(subghz->notifications, &sequence_set_red_255);
+}
+
+bool subghz_scene_show_error_sub_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubGhzCustomEventSceneShowErrorSub) {
+            scene_manager_search_and_switch_to_previous_scene(
+                subghz->scene_manager, SubGhzSceneStart);
+            return true;
+        }
+    }
+    return false;
+}
+
+void subghz_scene_show_error_sub_on_exit(void* context) {
+    SubGhz* subghz = context;
+
+    // Clear view
+    Popup* popup = subghz->popup;
+    popup_set_header(popup, NULL, 0, 0, AlignCenter, AlignBottom);
+    popup_set_text(popup, NULL, 0, 0, AlignCenter, AlignTop);
+    popup_set_icon(popup, 0, 0, NULL);
+    popup_set_callback(popup, NULL);
+    popup_set_context(popup, NULL);
+    popup_set_timeout(popup, 0);
+    popup_disable_timeout(popup);
+    string_reset(subghz->error_str);
+
+    notification_message(subghz->notifications, &sequence_reset_rgb);
+}
--- a/applications/main/subghz/scenes/subghz_scene_show_only_rx.c
+++ b/applications/main/subghz/scenes/subghz_scene_show_only_rx.c
@@ -0,0 +1,56 @@
+#include "../subghz_i.h"
+#include "../helpers/subghz_custom_event.h"
+
+void subghz_scene_show_only_rx_popup_callback(void* context) {
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, SubGhzCustomEventSceneShowOnlyRX);
+}
+
+void subghz_scene_show_only_rx_on_enter(void* context) {
+    SubGhz* subghz = context;
+
+    // Setup view
+    Popup* popup = subghz->popup;
+
+    const char* header_text = "Transmission is blocked";
+    const char* message_text = "Transmission on\nthis frequency is\nrestricted in\nyour region";
+    if(!furi_hal_region_is_provisioned()) {
+        header_text = "Firmware update needed";
+        message_text = "Please update\nfirmware before\nusing this feature\nflipp.dev/upd";
+    }
+
+    popup_set_header(popup, header_text, 63, 3, AlignCenter, AlignTop);
+    popup_set_text(popup, message_text, 0, 17, AlignLeft, AlignTop);
+    popup_set_icon(popup, 72, 17, &I_DolphinCommon_56x48);
+
+    popup_set_timeout(popup, 1500);
+    popup_set_context(popup, subghz);
+    popup_set_callback(popup, subghz_scene_show_only_rx_popup_callback);
+    popup_enable_timeout(popup);
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdPopup);
+}
+
+bool subghz_scene_show_only_rx_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubGhzCustomEventSceneShowOnlyRX) {
+            scene_manager_previous_scene(subghz->scene_manager);
+            return true;
+        }
+    }
+    return false;
+}
+
+void subghz_scene_show_only_rx_on_exit(void* context) {
+    SubGhz* subghz = context;
+
+    // Clear view
+    Popup* popup = subghz->popup;
+    popup_set_header(popup, NULL, 0, 0, AlignCenter, AlignBottom);
+    popup_set_text(popup, NULL, 0, 0, AlignCenter, AlignTop);
+    popup_set_icon(popup, 0, 0, NULL);
+    popup_set_callback(popup, NULL);
+    popup_set_context(popup, NULL);
+    popup_set_timeout(popup, 0);
+    popup_disable_timeout(popup);
+}
--- a/applications/main/subghz/scenes/subghz_scene_start.c
+++ b/applications/main/subghz/scenes/subghz_scene_start.c
@@ -0,0 +1,101 @@
+#include "../subghz_i.h"
+
+enum SubmenuIndex {
+    SubmenuIndexRead = 10,
+    SubmenuIndexSaved,
+    SubmenuIndexTest,
+    SubmenuIndexAddManualy,
+    SubmenuIndexFrequencyAnalyzer,
+    SubmenuIndexReadRAW,
+};
+
+void subghz_scene_start_submenu_callback(void* context, uint32_t index) {
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, index);
+}
+
+void subghz_scene_start_on_enter(void* context) {
+    SubGhz* subghz = context;
+    if(subghz->state_notifications == SubGhzNotificationStateStarting) {
+        subghz->state_notifications = SubGhzNotificationStateIDLE;
+    }
+    submenu_add_item(
+        subghz->submenu, "Read", SubmenuIndexRead, subghz_scene_start_submenu_callback, subghz);
+    submenu_add_item(
+        subghz->submenu,
+        "Read RAW",
+        SubmenuIndexReadRAW,
+        subghz_scene_start_submenu_callback,
+        subghz);
+    submenu_add_item(
+        subghz->submenu, "Saved", SubmenuIndexSaved, subghz_scene_start_submenu_callback, subghz);
+    submenu_add_item(
+        subghz->submenu,
+        "Add Manually",
+        SubmenuIndexAddManualy,
+        subghz_scene_start_submenu_callback,
+        subghz);
+    submenu_add_item(
+        subghz->submenu,
+        "Frequency Analyzer",
+        SubmenuIndexFrequencyAnalyzer,
+        subghz_scene_start_submenu_callback,
+        subghz);
+    if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
+        submenu_add_item(
+            subghz->submenu, "Test", SubmenuIndexTest, subghz_scene_start_submenu_callback, subghz);
+    }
+    submenu_set_selected_item(
+        subghz->submenu, scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneStart));
+
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdMenu);
+}
+
+bool subghz_scene_start_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+    if(event.type == SceneManagerEventTypeBack) {
+        //exit app
+        scene_manager_stop(subghz->scene_manager);
+        view_dispatcher_stop(subghz->view_dispatcher);
+        return true;
+    } else if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubmenuIndexReadRAW) {
+            scene_manager_set_scene_state(
+                subghz->scene_manager, SubGhzSceneStart, SubmenuIndexReadRAW);
+            subghz->txrx->rx_key_state = SubGhzRxKeyStateIDLE;
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneReadRAW);
+            return true;
+        } else if(event.event == SubmenuIndexRead) {
+            scene_manager_set_scene_state(
+                subghz->scene_manager, SubGhzSceneStart, SubmenuIndexRead);
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneReceiver);
+            return true;
+        } else if(event.event == SubmenuIndexSaved) {
+            scene_manager_set_scene_state(
+                subghz->scene_manager, SubGhzSceneStart, SubmenuIndexSaved);
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneSaved);
+            return true;
+        } else if(event.event == SubmenuIndexAddManualy) {
+            scene_manager_set_scene_state(
+                subghz->scene_manager, SubGhzSceneStart, SubmenuIndexAddManualy);
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneSetType);
+            return true;
+        } else if(event.event == SubmenuIndexFrequencyAnalyzer) {
+            scene_manager_set_scene_state(
+                subghz->scene_manager, SubGhzSceneStart, SubmenuIndexFrequencyAnalyzer);
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneFrequencyAnalyzer);
+            return true;
+        } else if(event.event == SubmenuIndexTest) {
+            scene_manager_set_scene_state(
+                subghz->scene_manager, SubGhzSceneStart, SubmenuIndexTest);
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneTest);
+            return true;
+        }
+    }
+    return false;
+}
+
+void subghz_scene_start_on_exit(void* context) {
+    SubGhz* subghz = context;
+    submenu_reset(subghz->submenu);
+}
--- a/applications/main/subghz/scenes/subghz_scene_test.c
+++ b/applications/main/subghz/scenes/subghz_scene_test.c
@@ -0,0 +1,61 @@
+#include "../subghz_i.h"
+
+enum SubmenuIndex {
+    SubmenuIndexCarrier,
+    SubmenuIndexPacket,
+    SubmenuIndexStatic,
+};
+
+void subghz_scene_test_submenu_callback(void* context, uint32_t index) {
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, index);
+}
+
+void subghz_scene_test_on_enter(void* context) {
+    SubGhz* subghz = context;
+
+    submenu_add_item(
+        subghz->submenu,
+        "Carrier",
+        SubmenuIndexCarrier,
+        subghz_scene_test_submenu_callback,
+        subghz);
+    submenu_add_item(
+        subghz->submenu, "Packet", SubmenuIndexPacket, subghz_scene_test_submenu_callback, subghz);
+    submenu_add_item(
+        subghz->submenu, "Static", SubmenuIndexStatic, subghz_scene_test_submenu_callback, subghz);
+
+    submenu_set_selected_item(
+        subghz->submenu, scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneTest));
+
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdMenu);
+}
+
+bool subghz_scene_test_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubmenuIndexCarrier) {
+            scene_manager_set_scene_state(
+                subghz->scene_manager, SubGhzSceneTest, SubmenuIndexCarrier);
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneTestCarrier);
+            return true;
+        } else if(event.event == SubmenuIndexPacket) {
+            scene_manager_set_scene_state(
+                subghz->scene_manager, SubGhzSceneTest, SubmenuIndexPacket);
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneTestPacket);
+            return true;
+        } else if(event.event == SubmenuIndexStatic) {
+            scene_manager_set_scene_state(
+                subghz->scene_manager, SubGhzSceneTest, SubmenuIndexStatic);
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneTestStatic);
+            return true;
+        }
+    }
+    return false;
+}
+
+void subghz_scene_test_on_exit(void* context) {
+    SubGhz* subghz = context;
+    submenu_reset(subghz->submenu);
+}
--- a/applications/main/subghz/scenes/subghz_scene_test_carrier.c
+++ b/applications/main/subghz/scenes/subghz_scene_test_carrier.c
@@ -0,0 +1,30 @@
+#include "../subghz_i.h"
+#include "../views/subghz_test_carrier.h"
+
+void subghz_scene_test_carrier_callback(SubGhzTestCarrierEvent event, void* context) {
+    furi_assert(context);
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, event);
+}
+
+void subghz_scene_test_carrier_on_enter(void* context) {
+    SubGhz* subghz = context;
+    subghz_test_carrier_set_callback(
+        subghz->subghz_test_carrier, subghz_scene_test_carrier_callback, subghz);
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdTestCarrier);
+}
+
+bool subghz_scene_test_carrier_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubGhzTestCarrierEventOnlyRx) {
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowOnlyRx);
+            return true;
+        }
+    }
+    return false;
+}
+
+void subghz_scene_test_carrier_on_exit(void* context) {
+    UNUSED(context);
+}
--- a/applications/main/subghz/scenes/subghz_scene_test_packet.c
+++ b/applications/main/subghz/scenes/subghz_scene_test_packet.c
@@ -0,0 +1,30 @@
+#include "../subghz_i.h"
+#include "../views/subghz_test_packet.h"
+
+void subghz_scene_test_packet_callback(SubGhzTestPacketEvent event, void* context) {
+    furi_assert(context);
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, event);
+}
+
+void subghz_scene_test_packet_on_enter(void* context) {
+    SubGhz* subghz = context;
+    subghz_test_packet_set_callback(
+        subghz->subghz_test_packet, subghz_scene_test_packet_callback, subghz);
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdTestPacket);
+}
+
+bool subghz_scene_test_packet_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubGhzTestPacketEventOnlyRx) {
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowOnlyRx);
+            return true;
+        }
+    }
+    return false;
+}
+
+void subghz_scene_test_packet_on_exit(void* context) {
+    UNUSED(context);
+}
--- a/applications/main/subghz/scenes/subghz_scene_test_static.c
+++ b/applications/main/subghz/scenes/subghz_scene_test_static.c
@@ -0,0 +1,30 @@
+#include "../subghz_i.h"
+#include "../views/subghz_test_static.h"
+
+void subghz_scene_test_static_callback(SubGhzTestStaticEvent event, void* context) {
+    furi_assert(context);
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, event);
+}
+
+void subghz_scene_test_static_on_enter(void* context) {
+    SubGhz* subghz = context;
+    subghz_test_static_set_callback(
+        subghz->subghz_test_static, subghz_scene_test_static_callback, subghz);
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdStatic);
+}
+
+bool subghz_scene_test_static_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubGhzTestStaticEventOnlyRx) {
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowOnlyRx);
+            return true;
+        }
+    }
+    return false;
+}
+
+void subghz_scene_test_static_on_exit(void* context) {
+    UNUSED(context);
+}
--- a/applications/main/subghz/scenes/subghz_scene_transmitter.c
+++ b/applications/main/subghz/scenes/subghz_scene_transmitter.c
@@ -0,0 +1,112 @@
+#include "../subghz_i.h"
+#include "../views/transmitter.h"
+#include <dolphin/dolphin.h>
+
+void subghz_scene_transmitter_callback(SubGhzCustomEvent event, void* context) {
+    furi_assert(context);
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, event);
+}
+
+bool subghz_scene_transmitter_update_data_show(void* context) {
+    //ToDo Fix
+    SubGhz* subghz = context;
+
+    if(subghz->txrx->decoder_result) {
+        string_t key_str;
+        string_t frequency_str;
+        string_t modulation_str;
+
+        string_init(key_str);
+        string_init(frequency_str);
+        string_init(modulation_str);
+        uint8_t show_button = 0;
+
+        subghz_protocol_decoder_base_deserialize(
+            subghz->txrx->decoder_result, subghz->txrx->fff_data);
+        subghz_protocol_decoder_base_get_string(subghz->txrx->decoder_result, key_str);
+
+        if((subghz->txrx->decoder_result->protocol->flag & SubGhzProtocolFlag_Send) ==
+           SubGhzProtocolFlag_Send) {
+            show_button = 1;
+        }
+
+        subghz_get_frequency_modulation(subghz, frequency_str, modulation_str);
+        subghz_view_transmitter_add_data_to_show(
+            subghz->subghz_transmitter,
+            string_get_cstr(key_str),
+            string_get_cstr(frequency_str),
+            string_get_cstr(modulation_str),
+            show_button);
+
+        string_clear(frequency_str);
+        string_clear(modulation_str);
+        string_clear(key_str);
+
+        return true;
+    }
+    return false;
+}
+
+void subghz_scene_transmitter_on_enter(void* context) {
+    SubGhz* subghz = context;
+    DOLPHIN_DEED(DolphinDeedSubGhzSend);
+    if(!subghz_scene_transmitter_update_data_show(subghz)) {
+        view_dispatcher_send_custom_event(
+            subghz->view_dispatcher, SubGhzCustomEventViewTransmitterError);
+    }
+
+    subghz_view_transmitter_set_callback(
+        subghz->subghz_transmitter, subghz_scene_transmitter_callback, subghz);
+
+    subghz->state_notifications = SubGhzNotificationStateIDLE;
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdTransmitter);
+}
+
+bool subghz_scene_transmitter_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubGhzCustomEventViewTransmitterSendStart) {
+            subghz->state_notifications = SubGhzNotificationStateIDLE;
+            if(subghz->txrx->txrx_state == SubGhzTxRxStateRx) {
+                subghz_rx_end(subghz);
+            }
+            if((subghz->txrx->txrx_state == SubGhzTxRxStateIDLE) ||
+               (subghz->txrx->txrx_state == SubGhzTxRxStateSleep)) {
+                if(!subghz_tx_start(subghz, subghz->txrx->fff_data)) {
+                    scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowOnlyRx);
+                } else {
+                    subghz->state_notifications = SubGhzNotificationStateTx;
+                    subghz_scene_transmitter_update_data_show(subghz);
+                }
+            }
+            return true;
+        } else if(event.event == SubGhzCustomEventViewTransmitterSendStop) {
+            subghz->state_notifications = SubGhzNotificationStateIDLE;
+            if(subghz->txrx->txrx_state == SubGhzTxRxStateTx) {
+                subghz_tx_stop(subghz);
+                subghz_sleep(subghz);
+            }
+            return true;
+        } else if(event.event == SubGhzCustomEventViewTransmitterBack) {
+            subghz->state_notifications = SubGhzNotificationStateIDLE;
+            scene_manager_search_and_switch_to_previous_scene(
+                subghz->scene_manager, SubGhzSceneStart);
+            return true;
+        } else if(event.event == SubGhzCustomEventViewTransmitterError) {
+            string_set_str(subghz->error_str, "Protocol not\nfound!");
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowErrorSub);
+        }
+    } else if(event.type == SceneManagerEventTypeTick) {
+        if(subghz->state_notifications == SubGhzNotificationStateTx) {
+            notification_message(subghz->notifications, &sequence_blink_magenta_10);
+        }
+        return true;
+    }
+    return false;
+}
+
+void subghz_scene_transmitter_on_exit(void* context) {
+    SubGhz* subghz = context;
+    subghz->state_notifications = SubGhzNotificationStateIDLE;
+}