[FL-1610] SubGhz: scene based application, PT save and replay (#630)

* SubGhz: scene based application
* SubGhz: encoder/decoder separation, DMA streaming, update app and cli.
* SubGhz: 2 stage async tx complete, minor cleanup
* SubGhz: 2 stage async tx complete, FIX state pin end transmit
* SubGhz: Pricenton, receive TE signal
* SubGhz: Pricenton, add save data, add load data
* SubGhz: Add Read scene, Fix pricenton save, load funtion
* SubGhz: Add Read, Receiver, SaveName scene
* SubGhz: Read and Save (pricenton)
* SubGhz: add Load scence
* SubGhz: Fix select file scene, add load scene, add transmitter view, add send tx pricenton
* SubGhz: Fix pricenton encoder, fix transmitter send
* SubGhz: modified Pricenton Encoder (added guard time at the beginning), modified CC1101 config, code refactoring
* SubGhz: Fix pricenton encoder defalut TE
* Archive: Fix path and name SubGhz
* Archive: Fix name app SubGhz
* GubGhz: Came: add Save, Load key
* GubGhz: GateTX: add Save, Load key
* GubGhz: NeroSketch: add Save, Load key
* Github: better linters triggers
* SubGhz: adding fast loading keys Archive -> Run in app
* GubGhz: KeeLog: add Save, Load key, key generation from the serial number of the meter and the button
* SubGhz: format sources and fix compilation
* FuriHal: add subghz configuration description for AGC section
* SubGhz: save only protocols that can be saved. Cleanup.
* Github: lint on pull requests

Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>

applications/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,
+};

applications/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

applications/subghz/scenes/subghz_scene_analyze.c

@@ -0,0 +1,15 @@
+#include "../subghz_i.h"
+
+const void subghz_scene_analyze_on_enter(void* context) {
+    SubGhz* subghz = context;
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewAnalyze);
+}
+
+const bool subghz_scene_analyze_on_event(void* context, SceneManagerEvent event) {
+    // SubGhz* subghz = context;
+    return false;
+}
+
+const void subghz_scene_analyze_on_exit(void* context) {
+    // SubGhz* subghz = context;
+}

applications/subghz/scenes/subghz_scene_config.h

@@ -0,0 +1,12 @@
+ADD_SCENE(subghz, start, Start)
+ADD_SCENE(subghz, analyze, Analyze)
+ADD_SCENE(subghz, read, Read)
+ADD_SCENE(subghz, receiver, Receiver)
+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, static, Static)
+ADD_SCENE(subghz, test, Test)
+ADD_SCENE(subghz, test_carrier, TestCarrier)
+ADD_SCENE(subghz, test_packet, TestPacket)

applications/subghz/scenes/subghz_scene_read.c

@@ -0,0 +1,57 @@
+#include "../subghz_i.h"
+
+#define GUBGHZ_READ_CUSTOM_EVENT (10UL)
+
+void subghz_read_protocol_callback(SubGhzProtocolCommon* parser, void* context) {
+    furi_assert(context);
+    SubGhz* subghz = context;
+    subghz->protocol_result = parser;
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, GUBGHZ_READ_CUSTOM_EVENT);
+}
+void subghz_scene_read_callback(DialogExResult result, void* context) {
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, result);
+}
+
+const void subghz_scene_read_on_enter(void* context) {
+    SubGhz* subghz = context;
+
+    // Setup view
+    DialogEx* dialog_ex = subghz->dialog_ex;
+
+    dialog_ex_set_header(dialog_ex, "SubGhz 433.92", 36, 6, AlignLeft, AlignCenter);
+    dialog_ex_set_icon(dialog_ex, 10, 12, &I_RFIDDolphinReceive_97x61);
+
+    //Start CC1101 rx
+    subghz_begin(FuriHalSubGhzPresetOokAsync);
+    subghz_rx(433920000);
+    furi_hal_subghz_start_async_rx(subghz_worker_rx_callback, subghz->worker);
+    subghz_worker_start(subghz->worker);
+    subghz_protocol_enable_dump(subghz->protocol, subghz_read_protocol_callback, subghz);
+
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewDialogEx);
+}
+
+const bool subghz_scene_read_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == GUBGHZ_READ_CUSTOM_EVENT) {
+            scene_manager_next_scene(subghz->scene_manager, SubGhzViewReceiver);
+            return true;
+        }
+    }
+    return false;
+}
+
+const void subghz_scene_read_on_exit(void* context) {
+    SubGhz* subghz = context;
+
+    //Stop CC1101
+    subghz_worker_stop(subghz->worker);
+    furi_hal_subghz_stop_async_rx();
+    subghz_end();
+
+    DialogEx* dialog_ex = subghz->dialog_ex;
+    dialog_ex_set_header(dialog_ex, NULL, 0, 0, AlignCenter, AlignCenter);
+    dialog_ex_set_icon(dialog_ex, 0, 0, NULL);
+}

applications/subghz/scenes/subghz_scene_receiver.c

@@ -0,0 +1,37 @@
+#include "../subghz_i.h"
+#include "../views/subghz_receiver.h"
+
+void subghz_scene_receiver_callback(SubghzReceverEvent event, void* context) {
+    furi_assert(context);
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, event);
+}
+
+const void subghz_scene_receiver_on_enter(void* context) {
+    SubGhz* subghz = context;
+    SubghzReceiver* subghz_receiver = subghz->subghz_receiver;
+
+    subghz_receiver_set_callback(subghz_receiver, subghz_scene_receiver_callback, subghz);
+
+    subghz_receiver_set_protocol(subghz_receiver, subghz->protocol_result);
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewReceiver);
+}
+
+const bool subghz_scene_receiver_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubghzReceverEventSave) {
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneSaveName);
+            return true;
+        } else if(event.event == SubghzReceverEventBack) {
+            scene_manager_previous_scene(subghz->scene_manager);
+            return true;
+        }
+    }
+    return false;
+}
+
+const void subghz_scene_receiver_on_exit(void* context) {
+    // SubGhz* subghz = context;
+}

applications/subghz/scenes/subghz_scene_save_name.c

@@ -0,0 +1,102 @@
+#include "../subghz_i.h"
+#include <lib/toolbox/random_name.h>
+#include "file-worker.h"
+
+#define SCENE_SAVE_NAME_CUSTOM_EVENT (0UL)
+
+bool subghz_scene_save_data_to_file(void* context, const char* dev_name) {
+    SubGhz* subghz = context;
+    FileWorker* file_worker = file_worker_alloc(false);
+    string_t dev_file_name;
+    string_init(dev_file_name);
+    string_t temp_str;
+    string_init(temp_str);
+    bool saved = false;
+
+    do {
+        // Create subghz folder directory if necessary
+        if(!file_worker_mkdir(file_worker, SUBGHZ_APP_FOLDER)) {
+            break;
+        }
+        // Create saved directory if necessary
+        if(!file_worker_mkdir(file_worker, SUBGHZ_APP_PATH_FOLDER)) {
+            break;
+        }
+        // First remove subghz device file if it was saved
+        string_printf(
+            dev_file_name, "%s/%s%s", SUBGHZ_APP_PATH_FOLDER, dev_name, SUBGHZ_APP_EXTENSION);
+        if(!file_worker_remove(file_worker, string_get_cstr(dev_file_name))) {
+            break;
+        }
+        // Open file
+        if(!file_worker_open(
+               file_worker, string_get_cstr(dev_file_name), FSAM_WRITE, FSOM_CREATE_ALWAYS)) {
+            break;
+        }
+        //Get string save
+        subghz->protocol_result->to_save_string(subghz->protocol_result, temp_str);
+        // Prepare and write data to file
+        if(!file_worker_write(file_worker, string_get_cstr(temp_str), string_size(temp_str))) {
+            break;
+        }
+        saved = true;
+    } while(0);
+
+    string_clear(temp_str);
+    string_clear(dev_file_name);
+    file_worker_close(file_worker);
+    file_worker_free(file_worker);
+
+    return saved;
+}
+
+void subghz_scene_save_name_text_input_callback(void* context) {
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, SCENE_SAVE_NAME_CUSTOM_EVENT);
+}
+
+const 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;
+
+    set_random_name(subghz->text_store, sizeof(subghz->text_store));
+    dev_name_empty = true;
+
+    text_input_set_header_text(text_input, "Name the KEY");
+    text_input_set_result_callback(
+        text_input,
+        subghz_scene_save_name_text_input_callback,
+        subghz,
+        subghz->text_store,
+        22, //Max len name
+        dev_name_empty);
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewTextInput);
+}
+
+const bool subghz_scene_save_name_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SCENE_SAVE_NAME_CUSTOM_EVENT) {
+            if(subghz_scene_save_data_to_file(subghz, subghz->text_store)) {
+                scene_manager_next_scene(subghz->scene_manager, SubGhzSceneSaveSuccess);
+                return true;
+            } else {
+                //Error save
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+const void subghz_scene_save_name_on_exit(void* context) {
+    SubGhz* subghz = context;
+
+    // Clear view
+    text_input_set_header_text(subghz->text_input, NULL);
+    text_input_set_result_callback(subghz->text_input, NULL, NULL, NULL, 0, false);
+}

applications/subghz/scenes/subghz_scene_save_success.c

@@ -0,0 +1,47 @@
+#include "../subghz_i.h"
+
+#define SCENE_SAVE_SUCCESS_CUSTOM_EVENT (0UL)
+
+void subghz_scene_save_success_popup_callback(void* context) {
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, SCENE_SAVE_SUCCESS_CUSTOM_EVENT);
+}
+
+const void subghz_scene_save_success_on_enter(void* context) {
+    SubGhz* subghz = context;
+
+    // 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, SubGhzViewPopup);
+}
+
+const bool subghz_scene_save_success_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SCENE_SAVE_SUCCESS_CUSTOM_EVENT) {
+            return scene_manager_search_and_switch_to_previous_scene(
+                subghz->scene_manager, SubGhzSceneStart);
+        }
+    }
+    return false;
+}
+
+const 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);
+}

applications/subghz/scenes/subghz_scene_saved.c

@@ -0,0 +1,88 @@
+#include "../subghz_i.h"
+
+bool subghz_scene_saved_file_select(SubGhz* subghz) {
+    furi_assert(subghz);
+
+    FileWorker* file_worker = file_worker_alloc(false);
+    string_t protocol_file_name;
+    string_init(protocol_file_name);
+    string_t temp_str;
+    string_init(temp_str);
+
+    // Input events and views are managed by file_select
+    bool res = file_worker_file_select(
+        file_worker,
+        SUBGHZ_APP_PATH_FOLDER,
+        SUBGHZ_APP_EXTENSION,
+        subghz->text_store,
+        sizeof(subghz->text_store),
+        NULL);
+
+    if(res) {
+        // Get key file path
+        string_printf(
+            protocol_file_name,
+            "%s/%s%s",
+            SUBGHZ_APP_PATH_FOLDER,
+            subghz->text_store,
+            SUBGHZ_APP_EXTENSION);
+    } else {
+        string_clear(temp_str);
+        string_clear(protocol_file_name);
+
+        file_worker_close(file_worker);
+        file_worker_free(file_worker);
+        return res;
+    }
+
+    do {
+        if(!file_worker_open(
+               file_worker, string_get_cstr(protocol_file_name), FSAM_READ, FSOM_OPEN_EXISTING)) {
+            break;
+        }
+        // Read and parse name protocol from 1st line
+        if(!file_worker_read_until(file_worker, temp_str, '\n')) {
+            break;
+        }
+        // strlen("Protocol: ") = 10
+        string_right(temp_str, 10);
+        subghz->protocol_result =
+            subghz_protocol_get_by_name(subghz->protocol, string_get_cstr(temp_str));
+        if(subghz->protocol_result == NULL) {
+            file_worker_show_error(file_worker, "Cannot parse\nfile");
+            break;
+        }
+        if(!subghz->protocol_result->to_load_protocol(file_worker, subghz->protocol_result)) {
+            file_worker_show_error(file_worker, "Cannot parse\nfile");
+            break;
+        }
+        res = true;
+    } while(0);
+
+    string_clear(temp_str);
+    string_clear(protocol_file_name);
+
+    file_worker_close(file_worker);
+    file_worker_free(file_worker);
+
+    return res;
+}
+
+const void subghz_scene_saved_on_enter(void* context) {
+    SubGhz* subghz = context;
+
+    if(subghz_scene_saved_file_select(subghz)) {
+        scene_manager_next_scene(subghz->scene_manager, SubGhzSceneTransmitter);
+    } else {
+        scene_manager_search_and_switch_to_previous_scene(subghz->scene_manager, SubGhzSceneStart);
+    }
+}
+
+const bool subghz_scene_saved_on_event(void* context, SceneManagerEvent event) {
+    // SubGhz* subghz = context;
+    return false;
+}
+
+const void subghz_scene_saved_on_exit(void* context) {
+    // SubGhz* subghz = context;
+}

applications/subghz/scenes/subghz_scene_start.c

@@ -0,0 +1,77 @@
+#include "../subghz_i.h"
+
+enum SubmenuIndex {
+    SubmenuIndexAnalyze,
+    SubmenuIndexRead,
+    SubmenuIndexSaved,
+    SubmenuIndexStatic,
+    SubmenuIndexTest,
+};
+
+void subghz_scene_start_submenu_callback(void* context, uint32_t index) {
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, index);
+}
+
+const void subghz_scene_start_on_enter(void* context) {
+    SubGhz* subghz = context;
+
+    submenu_add_item(
+        subghz->submenu,
+        "Analyze",
+        SubmenuIndexAnalyze,
+        subghz_scene_start_submenu_callback,
+        subghz);
+    submenu_add_item(
+        subghz->submenu, "Read", SubmenuIndexRead, subghz_scene_start_submenu_callback, subghz);
+    submenu_add_item(
+        subghz->submenu, "Saved", SubmenuIndexSaved, subghz_scene_start_submenu_callback, subghz);
+    submenu_add_item(
+        subghz->submenu, "Static", SubmenuIndexStatic, subghz_scene_start_submenu_callback, subghz);
+    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, SubGhzViewMenu);
+}
+
+const bool subghz_scene_start_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubmenuIndexAnalyze) {
+            scene_manager_set_scene_state(
+                subghz->scene_manager, SubGhzSceneStart, SubmenuIndexAnalyze);
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneAnalyze);
+            return true;
+        } else if(event.event == SubmenuIndexRead) {
+            scene_manager_set_scene_state(
+                subghz->scene_manager, SubGhzSceneStart, SubmenuIndexRead);
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneRead);
+            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 == SubmenuIndexStatic) {
+            scene_manager_set_scene_state(
+                subghz->scene_manager, SubGhzSceneStart, SubmenuIndexStatic);
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneStatic);
+            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;
+}
+
+const void subghz_scene_start_on_exit(void* context) {
+    SubGhz* subghz = context;
+    submenu_clean(subghz->submenu);
+}

applications/subghz/scenes/subghz_scene_static.c

@@ -0,0 +1,15 @@
+#include "../subghz_i.h"
+
+const void subghz_scene_static_on_enter(void* context) {
+    SubGhz* subghz = context;
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewStatic);
+}
+
+const bool subghz_scene_static_on_event(void* context, SceneManagerEvent event) {
+    // SubGhz* subghz = context;
+    return false;
+}
+
+const void subghz_scene_static_on_exit(void* context) {
+    // SubGhz* subghz = context;
+}

applications/subghz/scenes/subghz_scene_test.c

@@ -0,0 +1,53 @@
+#include "../subghz_i.h"
+
+enum SubmenuIndex {
+    SubmenuIndexCarrier,
+    SubmenuIndexPacket,
+};
+
+void subghz_scene_test_submenu_callback(void* context, uint32_t index) {
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, index);
+}
+
+const 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_set_selected_item(
+        subghz->submenu, scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneTest));
+
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewMenu);
+}
+
+const 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;
+        }
+    }
+    return false;
+}
+
+const void subghz_scene_test_on_exit(void* context) {
+    SubGhz* subghz = context;
+    submenu_clean(subghz->submenu);
+}

applications/subghz/scenes/subghz_scene_test_carrier.c

@@ -0,0 +1,15 @@
+#include "../subghz_i.h"
+
+const void subghz_scene_test_carrier_on_enter(void* context) {
+    SubGhz* subghz = context;
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewTestCarrier);
+}
+
+const bool subghz_scene_test_carrier_on_event(void* context, SceneManagerEvent event) {
+    // SubGhz* subghz = context;
+    return false;
+}
+
+const void subghz_scene_test_carrier_on_exit(void* context) {
+    // SubGhz* subghz = context;
+}

applications/subghz/scenes/subghz_scene_test_packet.c

@@ -0,0 +1,15 @@
+#include "../subghz_i.h"
+
+const void subghz_scene_test_packet_on_enter(void* context) {
+    SubGhz* subghz = context;
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewTestPacket);
+}
+
+const bool subghz_scene_test_packet_on_event(void* context, SceneManagerEvent event) {
+    // SubGhz* subghz = context;
+    return false;
+}
+
+const void subghz_scene_test_packet_on_exit(void* context) {
+    // SubGhz* subghz = context;
+}

applications/subghz/scenes/subghz_scene_transmitter.c

@@ -0,0 +1,65 @@
+#include "../subghz_i.h"
+#include "../views/subghz_transmitter.h"
+#include "lib/subghz/protocols/subghz_protocol_princeton.h"
+
+void subghz_scene_transmitter_tx(void* context) {
+    SubGhz* subghz = context;
+    SubGhzEncoderPrinceton* encoder = subghz_encoder_princeton_alloc();
+
+    subghz_encoder_princeton_reset(encoder, subghz->protocol_result->code_last_found, 4);
+    subghz_encoder_princeton_set_te(encoder, subghz->protocol_result);
+
+    subghz_begin(FuriHalSubGhzPresetOokAsync);
+    subghz_tx(433920000);
+
+    furi_hal_subghz_start_async_tx(subghz_encoder_princeton_yield, encoder);
+
+    while(!furi_hal_subghz_is_async_tx_complete()) {
+        osDelay(20);
+    }
+
+    //Stop tx
+    furi_hal_subghz_stop_async_tx();
+    subghz_end();
+    subghz_encoder_princeton_free(encoder);
+}
+
+void subghz_scene_transmitter_callback(SubghzTransmitterEvent event, void* context) {
+    furi_assert(context);
+    SubGhz* subghz = context;
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, event);
+}
+
+const void subghz_scene_transmitter_on_enter(void* context) {
+    SubGhz* subghz = context;
+    SubghzTransmitter* subghz_transmitter = subghz->subghz_transmitter;
+
+    subghz_transmitter_set_callback(subghz_transmitter, subghz_scene_transmitter_callback, subghz);
+
+    subghz_transmitter_set_protocol(subghz_transmitter, subghz->protocol_result);
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewTransmitter);
+}
+
+const bool subghz_scene_transmitter_on_event(void* context, SceneManagerEvent event) {
+    SubGhz* subghz = context;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubghzTransmitterEventSend) {
+            //scene_manager_next_scene(subghz->scene_manager, SubGhzSceneSaveName);
+            subghz_scene_transmitter_tx(subghz);
+            return true;
+        } else if(event.event == SubghzTransmitterEventBack) {
+            scene_manager_search_and_switch_to_previous_scene(
+                subghz->scene_manager, SubGhzSceneStart);
+            return true;
+        }
+    }
+    return false;
+}
+
+const void subghz_scene_transmitter_on_exit(void* context) {
+    SubGhz* subghz = context;
+    SubghzTransmitter* subghz_transmitter = subghz->subghz_transmitter;
+
+    subghz_transmitter_set_callback(subghz_transmitter, NULL, subghz);
+}