Last SubGHz settings is ready

applications/main/subghz/scenes/subghz_scene_need_saving.c

@@ -50,8 +50,8 @@ bool subghz_scene_need_saving_on_event(void* context, SceneManagerEvent event) {
                 subghz->txrx->rx_key_state = SubGhzRxKeyStateIDLE;
                 subghz_preset_init(
                     subghz,
-                    "AM650",
+                    subghz_setting_get_preset_name(subghz->setting, subghz->last_settings->preset),
-                    subghz_setting_get_default_frequency(subghz->setting),
+                    subghz->last_settings->frequency,
                     NULL,
                     0);
                 scene_manager_search_and_switch_to_previous_scene(

applications/main/subghz/scenes/subghz_scene_read_raw.c

@@ -131,13 +131,14 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
             if((subghz->txrx->rx_key_state == SubGhzRxKeyStateAddKey) ||
                (subghz->txrx->rx_key_state == SubGhzRxKeyStateBack)) {
                 subghz->txrx->rx_key_state = SubGhzRxKeyStateExit;
+                subghz->current_scene = SubGhzSceneNeedSaving;
                 scene_manager_next_scene(subghz->scene_manager, SubGhzSceneNeedSaving);
             } else {
                 //Restore default setting
                 subghz_preset_init(
                     subghz,
-                    "AM650",
+                    subghz_setting_get_preset_name(subghz->setting, subghz->last_settings->preset),
-                    subghz_setting_get_default_frequency(subghz->setting),
+                    subghz->last_settings->frequency,
                     NULL,
                     0);
                 if(!scene_manager_search_and_switch_to_previous_scene(
@@ -146,7 +147,11 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
                            subghz->scene_manager, SubGhzSceneStart)) {
                         scene_manager_stop(subghz->scene_manager);
                         view_dispatcher_stop(subghz->view_dispatcher);
+                    } else {
+                        subghz->current_scene = SubGhzSceneStart;
                     }
+                } else {
+                    subghz->current_scene = SubGhzSceneSaved;
                 }
             }
             consumed = true;
@@ -170,6 +175,7 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
         case SubGhzCustomEventViewReadRAWConfig:
             scene_manager_set_scene_state(
                 subghz->scene_manager, SubGhzSceneReadRAW, SubGhzCustomEventManagerSet);
+            subghz->current_scene = SubGhzSceneReceiverConfig;
             scene_manager_next_scene(subghz->scene_manager, SubGhzSceneReceiverConfig);
             consumed = true;
             break;
@@ -191,6 +197,7 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
                 scene_manager_set_scene_state(
                     subghz->scene_manager, SubGhzSceneReadRAW, SubGhzCustomEventManagerSet);
                 subghz->txrx->rx_key_state = SubGhzRxKeyStateRAWLoad;
+                subghz->current_scene = SubGhzSceneMoreRAW;
                 scene_manager_next_scene(subghz->scene_manager, SubGhzSceneMoreRAW);
                 consumed = true;
             } else {
@@ -210,6 +217,7 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
                    (subghz->txrx->txrx_state == SubGhzTxRxStateSleep)) {
                     if(!subghz_tx_start(subghz, subghz->txrx->fff_data)) {
                         subghz->txrx->rx_key_state = SubGhzRxKeyStateBack;
+                        subghz->current_scene = SubGhzSceneShowOnlyRx;
                         scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowOnlyRx);
                     } else {
                         DOLPHIN_DEED(DolphinDeedSubGhzSend);
@@ -269,6 +277,7 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
 
         case SubGhzCustomEventViewReadRAWREC:
             if(subghz->txrx->rx_key_state != SubGhzRxKeyStateIDLE) {
+                subghz->current_scene = SubGhzSceneNeedSaving;
                 scene_manager_next_scene(subghz->scene_manager, SubGhzSceneNeedSaving);
             } else {
                 //subghz_get_preset_name(subghz, subghz->error_str);
@@ -289,6 +298,7 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
                     subghz->txrx->rx_key_state = SubGhzRxKeyStateAddKey;
                 } else {
                     string_set_str(subghz->error_str, "Function requires\nan SD card.");
+                    subghz->current_scene = SubGhzSceneShowError;
                     scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowError);
                 }
             }
@@ -300,6 +310,7 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
                 scene_manager_set_scene_state(
                     subghz->scene_manager, SubGhzSceneReadRAW, SubGhzCustomEventManagerSetRAW);
                 subghz->txrx->rx_key_state = SubGhzRxKeyStateBack;
+                subghz->current_scene = SubGhzSceneSaveName;
                 scene_manager_next_scene(subghz->scene_manager, SubGhzSceneSaveName);
             }
             consumed = true;

applications/main/subghz/scenes/subghz_scene_receiver.c

@@ -1,6 +1,8 @@
 #include "../subghz_i.h"
 #include "../views/receiver.h"
 
+#define TAG "SubGhzSceneReceiver"
+
 const NotificationSequence subghz_sequence_rx = {
     &message_green_255,
 
@@ -103,7 +105,11 @@ void subghz_scene_receiver_on_enter(void* context) {
 
     if(subghz->txrx->rx_key_state == SubGhzRxKeyStateIDLE) {
         subghz_preset_init(
-            subghz, "AM650", subghz_setting_get_default_frequency(subghz->setting), NULL, 0);
+            subghz,
+            subghz_setting_get_preset_name(subghz->setting, subghz->last_settings->preset),
+            subghz->last_settings->frequency,
+            NULL,
+            0);
         subghz_history_reset(subghz->txrx->history);
         subghz->txrx->rx_key_state = SubGhzRxKeyStateStart;
     }
@@ -164,15 +170,17 @@ bool subghz_scene_receiver_on_event(void* context, SceneManagerEvent event) {
 
             if(subghz->txrx->rx_key_state == SubGhzRxKeyStateAddKey) {
                 subghz->txrx->rx_key_state = SubGhzRxKeyStateExit;
+                subghz->current_scene = SubGhzSceneNeedSaving;
                 scene_manager_next_scene(subghz->scene_manager, SubGhzSceneNeedSaving);
             } else {
                 subghz->txrx->rx_key_state = SubGhzRxKeyStateIDLE;
                 subghz_preset_init(
                     subghz,
-                    "AM650",
+                    subghz_setting_get_preset_name(subghz->setting, subghz->last_settings->preset),
-                    subghz_setting_get_default_frequency(subghz->setting),
+                    subghz->last_settings->frequency,
                     NULL,
                     0);
+                subghz->current_scene = SubGhzSceneStart;
                 scene_manager_search_and_switch_to_previous_scene(
                     subghz->scene_manager, SubGhzSceneStart);
             }
@@ -181,6 +189,7 @@ bool subghz_scene_receiver_on_event(void* context, SceneManagerEvent event) {
         case SubGhzCustomEventViewReceiverOK:
             subghz->txrx->idx_menu_chosen =
                 subghz_view_receiver_get_idx_menu(subghz->subghz_receiver);
+            subghz->current_scene = SubGhzSceneReceiverInfo;
             scene_manager_next_scene(subghz->scene_manager, SubGhzSceneReceiverInfo);
             consumed = true;
             break;
@@ -188,6 +197,9 @@ bool subghz_scene_receiver_on_event(void* context, SceneManagerEvent event) {
             subghz->state_notifications = SubGhzNotificationStateIDLE;
             subghz->txrx->idx_menu_chosen =
                 subghz_view_receiver_get_idx_menu(subghz->subghz_receiver);
+            scene_manager_set_scene_state(
+                subghz->scene_manager, SubGhzViewIdReceiver, SubGhzCustomEventManagerSet);
+            subghz->current_scene = SubGhzSceneReceiverConfig;
             scene_manager_next_scene(subghz->scene_manager, SubGhzSceneReceiverConfig);
             consumed = true;
             break;

applications/main/subghz/scenes/subghz_scene_receiver_config.c

@@ -145,6 +145,8 @@ static void subghz_scene_receiver_config_set_frequency(VariableItem* item) {
             (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);
+        subghz->last_settings->frequency = subghz->txrx->preset->frequency;
+        subghz_setting_set_default_frequency(subghz->setting, subghz->txrx->preset->frequency);
     } else {
         variable_item_set_current_value_index(
             item, subghz_setting_get_frequency_default_index(subghz->setting));
@@ -154,11 +156,13 @@ static void subghz_scene_receiver_config_set_frequency(VariableItem* item) {
 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(
+    const char* preset_name = subghz_setting_get_preset_name(subghz->setting, index);
-        item, subghz_setting_get_preset_name(subghz->setting, index));
+    variable_item_set_current_value_text(item, preset_name);
+    subghz->last_settings->preset = index;
+
     subghz_preset_init(
         subghz,
-        subghz_setting_get_preset_name(subghz->setting, index),
+        preset_name,
         subghz->txrx->preset->frequency,
         subghz_setting_get_preset_data(subghz->setting, index),
         subghz_setting_get_preset_data_size(subghz->setting, index));
@@ -246,8 +250,6 @@ void subghz_scene_receiver_config_on_enter(void* context) {
         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(
@@ -258,20 +260,6 @@ void subghz_scene_receiver_config_on_enter(void* context) {
         (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:",
@@ -286,6 +274,19 @@ void subghz_scene_receiver_config_on_enter(void* context) {
 
     if(scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneReadRAW) !=
        SubGhzCustomEventManagerSet) {
+        // Hopping
+        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]);
+
+        // Detect Raw
         item = variable_item_list_add(
             subghz->variable_item_list,
             "Detect Raw:",
@@ -298,10 +299,8 @@ void subghz_scene_receiver_config_on_enter(void* context) {
             DETECT_RAW_COUNT);
         variable_item_set_current_value_index(item, value_index);
         variable_item_set_current_value_text(item, detect_raw_text[value_index]);
-    }
 
-    if(scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneReadRAW) !=
+        // RSSI
-       SubGhzCustomEventManagerSet) {
         item = variable_item_list_add(
             subghz->variable_item_list,
             "RSSI for Raw:",
@@ -315,10 +314,8 @@ void subghz_scene_receiver_config_on_enter(void* context) {
             RSSI_THRESHOLD_COUNT);
         variable_item_set_current_value_index(item, value_index);
         variable_item_set_current_value_text(item, rssi_threshold_text[value_index]);
-    }
 
-    if(scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneReadRAW) !=
+        // Lock keyboard
-       SubGhzCustomEventManagerSet) {
         variable_item_list_add(subghz->variable_item_list, "Lock Keyboard", 1, NULL, NULL);
         variable_item_list_set_enter_callback(
             subghz->variable_item_list,
@@ -345,8 +342,8 @@ bool subghz_scene_receiver_config_on_event(void* context, SceneManagerEvent even
 
 void subghz_scene_receiver_config_on_exit(void* context) {
     SubGhz* subghz = context;
-    variable_item_list_set_selected_item(subghz->variable_item_list, 0);
     variable_item_list_reset(subghz->variable_item_list);
+    SAVE_SUBGHZ_LAST_SETTINGS(&subghz->last_settings);
     scene_manager_set_scene_state(
         subghz->scene_manager, SubGhzSceneReadRAW, SubGhzCustomEventManagerNoSet);
 }

applications/main/subghz/subghz.c

@@ -5,6 +5,8 @@
 #include <lib/toolbox/path.h>
 #include "subghz_i.h"
 
+#define TAG "SubGhzApp"
+
 bool subghz_custom_event_callback(void* context, uint32_t event) {
     furi_assert(context);
     SubGhz* subghz = context;
@@ -174,13 +176,30 @@ SubGhz* subghz_alloc() {
     subghz->setting = subghz_setting_alloc();
     subghz_setting_load(subghz->setting, EXT_PATH("subghz/assets/setting_user"));
 
+    // Load last used values for Read, Read RAW, etc. or default
+    subghz_last_settings_check_struct();
+    LOAD_SUBGHZ_LAST_SETTINGS(&subghz->last_settings);
+#if DEBUG
+    FURI_LOG_I(
+        TAG,
+        "last frequency: %d, preset: %d",
+        subghz->last_settings->frequency,
+        subghz->last_settings->preset);
+#endif
+    subghz_setting_set_default_frequency(subghz->setting, subghz->last_settings->frequency);
+    SAVE_SUBGHZ_LAST_SETTINGS(&subghz->last_settings);
+
     //init Worker & Protocol & History & KeyBoard
     subghz->lock = SubGhzLockOff;
     subghz->txrx = malloc(sizeof(SubGhzTxRx));
     subghz->txrx->preset = malloc(sizeof(SubGhzPresetDefinition));
     string_init(subghz->txrx->preset->name);
     subghz_preset_init(
-        subghz, "AM650", subghz_setting_get_default_frequency(subghz->setting), NULL, 0);
+        subghz,
+        subghz_setting_get_preset_name(subghz->setting, subghz->last_settings->preset),
+        subghz->last_settings->frequency,
+        NULL,
+        0);
 
     subghz->txrx->txrx_state = SubGhzTxRxStateSleep;
     subghz->txrx->hopper_state = SubGhzHopperStateOFF;

applications/main/subghz/subghz_i.h

@@ -33,6 +33,7 @@
 
 #include "subghz_history.h"
 #include "subghz_setting.h"
+#include "subghz_last_settings.h"
 
 #include <gui/modules/variable_item_list.h>
 #include <lib/toolbox/path.h>
@@ -100,10 +101,11 @@ struct SubGhz {
     SubGhzTestPacket* subghz_test_packet;
     string_t error_str;
     SubGhzSetting* setting;
+    SubGhzLastSettings* last_settings;
     SubGhzLock lock;
 
     bool in_decoder_scene;
-
+    SubGhzScene current_scene;
     void* rpc_ctx;
 };
 

applications/main/subghz/subghz_last_settings.c

@@ -0,0 +1,19 @@
+#include "subghz_last_settings.h"
+
+#define TAG "SubGhzLastSettings"
+
+// 1 = "AM650"
+// "AM270", "AM650", "FM238", "FM476",
+#define SUBGHZ_LAST_SETTING_DEFAULT_PRESET 1
+#define SUBGHZ_LAST_SETTING_DEFAULT_FREQUENCY 433920000
+
+void subghz_last_settings_check_struct(void) {
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+    if(!storage_file_exists(storage, SUBGHZ_LAST_SETTINGS_PATH)) {
+        SubGhzLastSettings* instance = malloc(sizeof(SubGhzLastSettings));
+        instance->frequency = SUBGHZ_LAST_SETTING_DEFAULT_FREQUENCY;
+        instance->preset = SUBGHZ_LAST_SETTING_DEFAULT_PRESET;
+        SAVE_SUBGHZ_LAST_SETTINGS(&instance);
+    }
+    furi_record_close(RECORD_STORAGE);
+}

applications/main/subghz/subghz_last_settings.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "subghz_last_settings_filename.h"
+
+#include <furi_hal.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <toolbox/saved_struct.h>
+#include <storage/storage.h>
+
+#define SUBGHZ_LAST_SETTINGS_VER (1)
+#define SUBGHZ_LAST_SETTINGS_PATH EXT_PATH(SUBGHZ_LAST_SETTINGS_FILE_NAME)
+#define SUBGHZ_LAST_SETTINGS_MAGIC (0xCC)
+
+#define SAVE_SUBGHZ_LAST_SETTINGS(x) \
+    saved_struct_save(               \
+        SUBGHZ_LAST_SETTINGS_PATH,   \
+        (x),                         \
+        sizeof(SubGhzLastSettings),  \
+        SUBGHZ_LAST_SETTINGS_MAGIC,  \
+        SUBGHZ_LAST_SETTINGS_VER)
+
+#define LOAD_SUBGHZ_LAST_SETTINGS(x) \
+    saved_struct_load(               \
+        SUBGHZ_LAST_SETTINGS_PATH,   \
+        (x),                         \
+        sizeof(SubGhzLastSettings),  \
+        SUBGHZ_LAST_SETTINGS_MAGIC,  \
+        SUBGHZ_LAST_SETTINGS_VER)
+
+typedef struct {
+    uint32_t frequency;
+    uint8_t preset;
+} SubGhzLastSettings;
+
+void subghz_last_settings_check_struct(void);

applications/main/subghz/subghz_last_settings_filename.h

@@ -0,0 +1,3 @@
+#pragma once
+
+#define SUBGHZ_LAST_SETTINGS_FILE_NAME ".subghz.settings"

applications/main/subghz/subghz_setting.c

@@ -260,13 +260,7 @@ void subghz_setting_load(SubGhzSetting* instance, const char* file_path) {
                 break;
             }
             if(flipper_format_read_uint32(fff_data_file, "Default_frequency", &temp_data32, 1)) {
-                for
+                subghz_setting_set_default_frequency(instance, temp_data32);
-                    M_EACH(frequency, instance->frequencies, FrequencyList_t) {
-                        *frequency &= FREQUENCY_MASK;
-                        if(*frequency == temp_data32) {
-                            *frequency |= FREQUENCY_FLAG_DEFAULT;
-                        }
-                    }
             }
 
             // custom preset (optional)
@@ -294,6 +288,16 @@ void subghz_setting_load(SubGhzSetting* instance, const char* file_path) {
     }
 }
 
+void subghz_setting_set_default_frequency(SubGhzSetting* instance, uint32_t frequency_to_setup) {
+    for
+        M_EACH(frequency, instance->frequencies, FrequencyList_t) {
+            *frequency &= FREQUENCY_MASK;
+            if(*frequency == frequency_to_setup) {
+                *frequency |= FREQUENCY_FLAG_DEFAULT;
+            }
+        }
+}
+
 size_t subghz_setting_get_frequency_count(SubGhzSetting* instance) {
     furi_assert(instance);
     return FrequencyList_size(instance->frequencies);
@@ -311,6 +315,9 @@ size_t subghz_setting_get_preset_count(SubGhzSetting* instance) {
 
 const char* subghz_setting_get_preset_name(SubGhzSetting* instance, size_t idx) {
     furi_assert(instance);
+    if(idx >= SubGhzSettingCustomPresetItemArray_size(instance->preset->data)) {
+        idx = 0;
+    }
     SubGhzSettingCustomPresetItem* item =
         SubGhzSettingCustomPresetItemArray_get(instance->preset->data, idx);
     return string_get_cstr(item->custom_preset_name);

applications/main/subghz/subghz_setting.h

@@ -46,3 +46,5 @@ uint32_t subghz_setting_get_hopper_frequency(SubGhzSetting* instance, size_t idx
 uint32_t subghz_setting_get_frequency_default_index(SubGhzSetting* instance);
 
 uint32_t subghz_setting_get_default_frequency(SubGhzSetting* instance);
+
+void subghz_setting_set_default_frequency(SubGhzSetting* instance, uint32_t frequency_to_setup);