Merge remote-tracking branch 'origin/uldev' into 420-newfaps

.drone.yml

@@ -28,35 +28,6 @@ steps:
       FBT_TOOLS_CUSTOM_LINK:
         from_secret: fbt_link
 
-  - name: "Bundle resources"
-    image: kramos/alpine-zip
-    commands:
-      - mkdir sd-card
-      - mkdir -p sd-card/subghz/assets
-      - mkdir -p sd-card/nfc/assets
-      - mkdir -p sd-card/infrared/assets
-      - mkdir -p sd-card/unirf
-      - mkdir -p sd-card/rfidfuzzer
-      - mkdir -p sd-card/subplaylist
-      - mkdir -p sd-card/badusb/layouts
-      - cp assets/resources/badusb/layouts/* sd-card/badusb/layouts/
-      - cp assets/resources/subghz/assets/dangerous_settings sd-card/subghz/assets/dangerous_settings
-      - cp assets/resources/subghz/assets/setting_user sd-card/subghz/assets/setting_user
-      - cp assets/resources/subghz/assets/keeloq_mfcodes sd-card/subghz/assets/keeloq_mfcodes
-      - cp assets/resources/nfc/assets/mf_classic_dict.nfc sd-card/nfc/assets/mf_classic_dict.nfc
-      - cp assets/resources/infrared/assets/tv.ir sd-card/infrared/assets/tv.ir
-      - cp assets/resources/infrared/assets/ac.ir sd-card/infrared/assets/ac.ir
-      - cp assets/resources/infrared/assets/fans.ir sd-card/infrared/assets/fans.ir
-      - cp assets/resources/infrared/assets/projectors.ir sd-card/infrared/assets/projectors.ir
-      - cp assets/resources/infrared/assets/audio.ir sd-card/infrared/assets/audio.ir
-      - cp assets/resources/unirf/unirf_map_example.txt sd-card/unirf/unirf_map_example.txt
-      - cp assets/resources/rfidfuzzer/example_uids.txt sd-card/rfidfuzzer/example_uids.txt
-      - cp assets/resources/subplaylist/example_playlist.txt sd-card/subplaylist/example_playlist.txt
-      - cp assets/resources/Manifest sd-card/Manifest
-      - zip -r artifacts-default/sd-card-${DRONE_TAG}.zip sd-card
-      - rm -rf sd-card
-      - ls -laS artifacts-default
-
   - name: "Bundle self-update packages"
     image: kramos/alpine-zip
     commands:
@@ -93,7 +64,6 @@ steps:
       files:
         - artifacts-default/*.tgz
         - artifacts-default/*.zip
-        - artifacts-default/flipper-z-f7-full-${DRONE_TAG}.dfu
       title: ${DRONE_TAG}
       note: CHANGELOG.md
       checksum:

CHANGELOG.md

@@ -1,22 +1,10 @@
 ### New changes
-* Critical issue fix: Fixed subghz read mode doesn’t work at all
-* Updated archive app (Rename, File info) (+ fixes) (by @derskythe) [(PR 68)](https://github.com/Eng1n33r/flipperzero-firmware/pull/68)
-* Plugins: Added uart echo and usb mouse apps
-* Plugins: Fix nrfsniff log spam, add new icons for plugins (icons by @Svaarich)
-* Plugins: Changed app types and added new category for music players
-* Plugins: Added new start screen for doom (by @Svaarich)
-* Reduced max SubGHz history items to resolve memory issues, was 99, now 65
-* Updated universal remote assets (by @Amec0e)
-* OFW: Fbt: fixed gdb-py path for MacOS
-
-**Known issues: Picopass reader plugin crash**
+* Picopass plugin fixed (bug with mbedtls lib found and fixed by hedger in OFW PR 1742)
+* DFU files no longer included in releases to avoid issues with wrong manual installation of assets - use web updater or microSD update package
 
 **Note: To avoid issues prefer installing using web updater or by self update package, all needed assets will be installed**
 
 Self-update package (update from microSD) - `flipper-z-f7-update-(version).zip` or `.tgz` for iOS mobile app
 
-DFU for update using qFlipper - `flipper-z-f7-full-(version).dfu`
-
-If using DFU update method, download this archive and unpack it to your microSD, replacing all files except files you have edited manually -
-`sd-card-(version).zip`
+DFU for update using qFlipper is no longer included in releases to avoid issues with assets - Use Web Updater or self-update package!
 

applications/main/subghz/scenes/subghz_scene_decode_raw.c

@@ -112,7 +112,7 @@ bool subghz_scene_decode_raw_start(SubGhz* subghz) {
     } while(false);
 
     if(success) {
-        FURI_LOG_I(TAG, "Listening at \033[0;33m%s\033[0m.", string_get_cstr(file_name));
+        //FURI_LOG_I(TAG, "Listening at \033[0;33m%s\033[0m.", string_get_cstr(file_name));
 
         file_worker_encoder = subghz_file_encoder_worker_alloc();
         if(subghz_file_encoder_worker_start(file_worker_encoder, string_get_cstr(file_name))) {
@@ -180,7 +180,8 @@ void subghz_scene_decode_raw_on_enter(void* context) {
         subghz_receiver_search_decoder_base_by_name(
             subghz->txrx->receiver, SUBGHZ_PROTOCOL_RAW_NAME),
         false);
-
+    subghz_receiver_set_filter(subghz->txrx->receiver, SubGhzProtocolFlag_Decodable);
+    
     if(decode_raw_state == SubGhzDecodeRawStateStart) {
         //Decode RAW to history
         subghz_history_reset(subghz->txrx->history);
@@ -237,7 +238,7 @@ bool subghz_scene_decode_raw_on_event(void* context, SceneManagerEvent event) {
             consumed = true;
             break;
         case SubGhzCustomEventViewReceiverConfig:
-            FURI_LOG_I(TAG, "No config options");
+            FURI_LOG_W(TAG, "No config options");
             consumed = true;
             break;
         case SubGhzCustomEventViewReceiverOffDisplay:
@@ -257,7 +258,7 @@ bool subghz_scene_decode_raw_on_event(void* context, SceneManagerEvent event) {
             notification_message(subghz->notifications, &sequence_blink_cyan_10);
             break;
         case SubGhzNotificationStateRxDone:
-            notification_message(subghz->notifications, &subghs_sequence_rx);
+            notification_message(subghz->notifications, &subghz_sequence_rx);
             subghz->state_notifications = SubGhzNotificationStateRx;
             break;
         default:

applications/main/subghz/scenes/subghz_scene_read_raw.c

@@ -115,6 +115,7 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
         case SubGhzCustomEventViewReadRAWBack:
             // Check if return from config save values
             if(subghz->current_scene == SubGhzSceneReceiverConfig) {
+                //FURI_LOG_I(TAG, "Raw value: %d", subghz->last_setting->detect_raw);
                 subghz_last_setting_save(
                     subghz->last_setting, EXT_PATH("subghz/assets/last_used.txt"));
             }
@@ -181,6 +182,7 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
             scene_manager_set_scene_state(
                 subghz->scene_manager, SubGhzSceneReadRAW, SubGhzCustomEventManagerSet);
             subghz->current_scene = SubGhzSceneReceiverConfig;
+            //FURI_LOG_I(TAG, "Raw value: %d", subghz->last_setting->detect_raw);
             scene_manager_next_scene(subghz->scene_manager, SubGhzSceneReceiverConfig);
             consumed = true;
             break;

applications/main/subghz/scenes/subghz_scene_receiver.c

@@ -1,7 +1,9 @@
 #include "../subghz_i.h"
 #include "../views/receiver.h"
 
-const NotificationSequence subghs_sequence_rx = {
+#define TAG "SubGhzSceneReceiver"
+
+const NotificationSequence subghz_sequence_rx = {
     &message_green_255,
 
     &message_vibro_on,
@@ -14,7 +16,7 @@ const NotificationSequence subghs_sequence_rx = {
     NULL,
 };
 
-const NotificationSequence subghs_sequence_rx_locked = {
+const NotificationSequence subghz_sequence_rx_locked = {
     &message_green_255,
 
     &message_display_backlight_on,
@@ -98,6 +100,8 @@ static void subghz_scene_add_to_history_callback(
 void subghz_scene_receiver_on_enter(void* context) {
     SubGhz* subghz = context;
 
+    subghz_last_setting_set_receiver_values(subghz->last_setting, subghz->txrx->receiver);
+
     string_t str_buff;
     string_init(str_buff);
 
@@ -136,9 +140,11 @@ void subghz_scene_receiver_on_enter(void* context) {
     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)) {
+        // Set values that can be reset after using DetectRAW Scene
+        subghz_last_setting_set_receiver_values(subghz->last_setting, subghz->txrx->receiver);
         subghz_begin(
             subghz,
             subghz_setting_get_preset_data_by_name(
@@ -158,6 +164,7 @@ bool subghz_scene_receiver_on_event(void* context, SceneManagerEvent event) {
         case SubGhzCustomEventViewReceiverBack:
             // Check if return from config save values
             if(subghz->current_scene == SubGhzSceneReceiverConfig) {
+                //FURI_LOG_I(TAG, "Raw value: %d", subghz->last_setting->detect_raw);
                 subghz_last_setting_save(
                     subghz->last_setting, EXT_PATH("subghz/assets/last_used.txt"));
             }
@@ -166,7 +173,7 @@ bool subghz_scene_receiver_on_event(void* context, SceneManagerEvent event) {
             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);
@@ -200,7 +207,10 @@ 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;
+            //FURI_LOG_I(TAG, "Raw value: %d", subghz->last_setting->detect_raw);
             scene_manager_next_scene(subghz->scene_manager, SubGhzSceneReceiverConfig);
             consumed = true;
             break;
@@ -226,9 +236,9 @@ bool subghz_scene_receiver_on_event(void* context, SceneManagerEvent event) {
             break;
         case SubGhzNotificationStateRxDone:
             if(subghz->lock != SubGhzLockOn) {
-                notification_message(subghz->notifications, &subghs_sequence_rx);
+                notification_message(subghz->notifications, &subghz_sequence_rx);
             } else {
-                notification_message(subghz->notifications, &subghs_sequence_rx_locked);
+                notification_message(subghz->notifications, &subghz_sequence_rx_locked);
             }
             subghz->state_notifications = SubGhzNotificationStateRx;
             break;
@@ -240,5 +250,8 @@ bool subghz_scene_receiver_on_event(void* context, SceneManagerEvent event) {
 }
 
 void subghz_scene_receiver_on_exit(void* context) {
-    UNUSED(context);
+    SubGhz* subghz = context;
+
+    //filter restoration
+    subghz_receiver_set_filter(subghz->txrx->receiver, SubGhzProtocolFlag_Decodable);
 }

applications/main/subghz/scenes/subghz_scene_receiver_config.c

@@ -2,6 +2,8 @@
 
 #include <lib/subghz/protocols/raw.h>
 
+#define TAG "SubGhzSceneReceiverConfig"
+
 enum SubGhzSettingIndex {
     SubGhzSettingIndexFrequency,
     SubGhzSettingIndexHopping,
@@ -186,8 +188,7 @@ static void subghz_scene_receiver_config_set_detect_raw(VariableItem* item) {
 
     variable_item_set_current_value_text(item, detect_raw_text[index]);
     subghz_receiver_set_filter(subghz->txrx->receiver, detect_raw_value[index]);
-
-    //subghz->last_setting->detect_raw = detect_raw_value[index];
+    subghz->last_setting->detect_raw = detect_raw_value[index];
 
     subghz_protocol_decoder_raw_set_auto_mode(
         subghz_receiver_search_decoder_base_by_name(
@@ -228,7 +229,8 @@ static void subghz_scene_receiver_config_set_hopping_running(VariableItem* item)
             subghz_setting_get_frequency_default_index(subghz->setting));
     }
 
-    subghz->txrx->hopper_state = subghz->last_setting->hopping = hopping_value[index];
+    subghz->txrx->hopper_state = hopping_value[index];
+    subghz->last_setting->hopping = hopping_value[index];
 }
 
 static void subghz_scene_receiver_config_var_list_enter_callback(void* context, uint32_t index) {
@@ -242,6 +244,9 @@ static void subghz_scene_receiver_config_var_list_enter_callback(void* context,
 
 void subghz_scene_receiver_config_on_enter(void* context) {
     SubGhz* subghz = context;
+
+    subghz_last_setting_set_receiver_values(subghz->last_setting, subghz->txrx->receiver);
+
     VariableItem* item;
     uint8_t value_index;
 
@@ -265,20 +270,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:",
@@ -293,6 +284,17 @@ void subghz_scene_receiver_config_on_enter(void* context) {
 
     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,
             "Detect Raw:",
@@ -305,10 +307,7 @@ 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) !=
-       SubGhzCustomEventManagerSet) {
         item = variable_item_list_add(
             subghz->variable_item_list,
             "RSSI for Raw:",
@@ -322,10 +321,7 @@ 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) !=
-       SubGhzCustomEventManagerSet) {
         variable_item_list_add(subghz->variable_item_list, "Lock Keyboard", 1, NULL, NULL);
         variable_item_list_set_enter_callback(
             subghz->variable_item_list,

applications/main/subghz/scenes/subghz_scene_show_error.c

@@ -1,7 +1,7 @@
 #include "../subghz_i.h"
 #include "../helpers/subghz_custom_event.h"
 
-static const NotificationSequence subghs_sequence_sd_error = {
+static const NotificationSequence subghz_sequence_sd_error = {
     &message_red_255,
     &message_green_255,
     &message_do_not_reset,
@@ -39,7 +39,7 @@ void subghz_scene_show_error_on_enter(void* context) {
         widget_add_button_element(
             subghz->widget, GuiButtonTypeRight, "OK", subghz_scene_show_error_callback, subghz);
     } else {
-        notification_message(subghz->notifications, &subghs_sequence_sd_error);
+        notification_message(subghz->notifications, &subghz_sequence_sd_error);
     }
 
     widget_add_button_element(

applications/main/subghz/subghz.c

@@ -1,9 +1,9 @@
 /* Abandon hope, all ye who enter here. */
 
-#include "m-string.h"
-#include "subghz/types.h"
-#include "subghz_i.h"
+#include <m-string.h>
+#include <subghz/types.h>
 #include <lib/toolbox/path.h>
+#include "subghz_i.h"
 
 bool subghz_custom_event_callback(void* context, uint32_t event) {
     furi_assert(context);
@@ -207,7 +207,7 @@ SubGhz* subghz_alloc() {
     subghz->txrx->receiver = subghz_receiver_alloc_init(subghz->txrx->environment);
 
     // Setup values
-    subghz_last_setting_set_receiver_values(subghz->last_setting, subghz->txrx->receiver);
+    subghz_receiver_set_filter(subghz->txrx->receiver, SubGhzProtocolFlag_Decodable);
 
     subghz_worker_set_overrun_callback(
         subghz->txrx->worker, (SubGhzWorkerOverrunCallback)subghz_receiver_reset);

applications/main/subghz/subghz_history.c

@@ -1,9 +1,5 @@
 #include "subghz_history.h"
 #include <lib/subghz/receiver.h>
-#include <lib/subghz/protocols/came.h>
-
-#include <furi.h>
-#include <m-string.h>
 
 #define SUBGHZ_HISTORY_MAX 65
 #define TAG "SubGhzHistory"
@@ -41,15 +37,9 @@ SubGhzHistory* subghz_history_alloc(void) {
 
 void subghz_history_free(SubGhzHistory* instance) {
     furi_assert(instance);
-    string_clear(instance->tmp_string);
-    for
-        M_EACH(item, instance->history->data, SubGhzHistoryItemArray_t) {
-            string_clear(item->item_str);
-            string_clear(item->preset->name);
-            free(item->preset);
-            flipper_format_free(item->flipper_string);
-            item->type = 0;
-        }
+
+    // Call method instead of code duplicate
+    subghz_history_reset(instance);
     SubGhzHistoryItemArray_clear(instance->history->data);
     free(instance->history);
     free(instance);
@@ -143,16 +133,22 @@ bool subghz_history_add_to_history(
     furi_assert(instance);
     furi_assert(context);
 
-    if(instance->last_index_write >= SUBGHZ_HISTORY_MAX) return false;
+    if(instance->last_index_write >= SUBGHZ_HISTORY_MAX) {
+        FURI_LOG_W(TAG, "Out of history slots!");
+        return false;
+    }
 
     SubGhzProtocolDecoderBase* decoder_base = context;
     if((instance->code_last_hash_data ==
         subghz_protocol_decoder_base_get_hash_data(decoder_base)) &&
        ((furi_get_tick() - instance->last_update_timestamp) < 500)) {
+        //FURI_LOG_W(TAG, "Too short period for add");
         instance->last_update_timestamp = furi_get_tick();
         return false;
     }
 
+    //FURI_LOG_I(TAG, "Add to history. Total: %d", instance->last_index_write + 1);
+
     instance->code_last_hash_data = subghz_protocol_decoder_base_get_hash_data(decoder_base);
     instance->last_update_timestamp = furi_get_tick();
 

applications/main/subghz/subghz_i.h

@@ -142,5 +142,5 @@ bool subghz_path_is_file(string_t path);
 uint32_t subghz_random_serial(void);
 void subghz_hopper_update(SubGhz* subghz);
 
-extern const NotificationSequence subghs_sequence_rx;
-extern const NotificationSequence subghs_sequence_rx_locked;
+extern const NotificationSequence subghz_sequence_rx;
+extern const NotificationSequence subghz_sequence_rx_locked;

applications/main/subghz/subghz_last_setting.c

@@ -1,12 +1,11 @@
 #include "subghz_setting.h"
 #include "subghz_i.h"
-
 #include "subghz_last_setting.h"
 
 #include <furi.h>
 #include <m-list.h>
-#include "furi_hal_subghz.h"
-#include "furi_hal_subghz_configs.h"
+#include <furi_hal_subghz.h>
+#include <furi_hal_subghz_configs.h>
 #include <lib/subghz/protocols/raw.h>
 
 #define TAG "SubGhzLastSetting"
@@ -41,7 +40,7 @@ void subghz_last_setting_load(SubGhzLastSetting* instance, const char* file_path
     string_init(temp_preset);
     uint32_t temp_frequency = 0; // Default 433920000
     uint32_t temp_hopping = 0; // Default 0
-    //uint32_t temp_detect_raw = 0;  Default 2
+    uint32_t temp_detect_raw = 0; // Default 2
     int32_t temp_rssi_threshold = 0; // Default -72
 
     if(FSE_OK == storage_sd_status(storage) && file_path &&
@@ -49,31 +48,31 @@ void subghz_last_setting_load(SubGhzLastSetting* instance, const char* file_path
         flipper_format_read_string(fff_data_file, "Preset", temp_preset);
         flipper_format_read_uint32(fff_data_file, "Frequency", (uint32_t*)&temp_frequency, 1);
         flipper_format_read_uint32(fff_data_file, "Hopping", (uint32_t*)&temp_hopping, 1);
-        //flipper_format_read_uint32(fff_data_file, "DetectRaw", (uint32_t*)&temp_detect_raw, 1);
+        flipper_format_read_uint32(fff_data_file, "DetectRaw", (uint32_t*)&temp_detect_raw, 1);
         flipper_format_read_int32(fff_data_file, "Rssi", (int32_t*)&temp_rssi_threshold, 1);
     } else {
         FURI_LOG_E(TAG, "Error open file %s", file_path);
     }
 
     if(string_empty_p(temp_preset)) {
-        //FURI_LOG_I(TAG, "Last used preset not found");
+        FURI_LOG_D(TAG, "Last used preset not found");
         string_set(instance->preset_name, SUBGHZ_LAST_SETTING_DEFAULT_PRESET);
     } else {
         string_set(instance->preset_name, temp_preset);
     }
 
     if(temp_frequency == 0 || !furi_hal_subghz_is_tx_allowed(temp_frequency)) {
-        //FURI_LOG_I(TAG, "Last used frequency not found or can't be used!");
+        FURI_LOG_D(TAG, "Last used frequency not found or can't be used!");
         instance->frequency = SUBGHZ_LAST_SETTING_DEFAULT_FREQUENCY;
     } else {
         instance->frequency = temp_frequency;
     }
 
-    /*if(temp_detect_raw == 0) {
+    if(temp_detect_raw == 0) {
         instance->detect_raw = SubGhzProtocolFlag_Decodable;
     } else {
         instance->detect_raw = temp_detect_raw;
-    }*/
+    }
 
     if(temp_rssi_threshold == 0) {
         instance->rssi_threshold = -72;
@@ -112,8 +111,8 @@ bool subghz_last_setting_save(SubGhzLastSetting* instance, const char* file_path
         if(!flipper_format_insert_or_update_uint32(file, "Frequency", &instance->frequency, 1))
             break;
         if(!flipper_format_insert_or_update_uint32(file, "Hopping", &instance->hopping, 1)) break;
-        //if(!flipper_format_insert_or_update_uint32(file, "DetectRaw", &instance->detect_raw, 1))
-        //    break;
+        if(!flipper_format_insert_or_update_uint32(file, "DetectRaw", &instance->detect_raw, 1))
+            break;
         if(!flipper_format_insert_or_update_int32(file, "Rssi", &instance->rssi_threshold, 1))
             break;
 
@@ -131,14 +130,11 @@ bool subghz_last_setting_save(SubGhzLastSetting* instance, const char* file_path
 }
 
 void subghz_last_setting_set_receiver_values(SubGhzLastSetting* instance, SubGhzReceiver* receiver) {
-    subghz_receiver_set_filter(receiver, SubGhzProtocolFlag_Decodable);
-    /*subghz_receiver_set_filter(receiver, instance->detect_raw);
+    SubGhzProtocolDecoderBase* protocolDecoderBase =
+        subghz_receiver_search_decoder_base_by_name(receiver, SUBGHZ_PROTOCOL_RAW_NAME);
 
+    subghz_receiver_set_filter(receiver, instance->detect_raw);
     subghz_protocol_decoder_raw_set_auto_mode(
-        subghz_receiver_search_decoder_base_by_name(receiver, SUBGHZ_PROTOCOL_RAW_NAME),
-        (instance->detect_raw != SubGhzProtocolFlag_Decodable));*/
-
-    subghz_protocol_decoder_raw_set_rssi_threshold(
-        subghz_receiver_search_decoder_base_by_name(receiver, SUBGHZ_PROTOCOL_RAW_NAME),
-        instance->rssi_threshold);
+        protocolDecoderBase, (instance->detect_raw != SubGhzProtocolFlag_Decodable));
+    subghz_protocol_decoder_raw_set_rssi_threshold(protocolDecoderBase, instance->rssi_threshold);
 }

applications/main/subghz/subghz_last_setting.h

@@ -9,7 +9,7 @@ typedef struct {
     string_t preset_name;
     uint32_t frequency;
     uint32_t hopping;
-    //uint32_t detect_raw;
+    uint32_t detect_raw;
     int32_t rssi_threshold;
 } SubGhzLastSetting;
 

applications/main/subghz/subghz_setting.c

@@ -3,7 +3,7 @@
 
 #include <furi.h>
 #include <m-list.h>
-#include "furi_hal_subghz_configs.h"
+#include <furi_hal_subghz_configs.h>
 
 #define TAG "SubGhzSetting"
 

applications/main/subghz/views/receiver.c

@@ -340,6 +340,7 @@ bool subghz_view_receiver_input(InputEvent* event, void* context) {
                 return true;
             });
     } else if(event->key == InputKeyLeft && event->type == InputTypeShort) {
+        //Config receiver
         subghz_receiver->callback(SubGhzCustomEventViewReceiverConfig, subghz_receiver->context);
     } else if(event->key == InputKeyOk && event->type == InputTypeShort) {
         with_view_model(

applications/plugins/picopass/picopass_device.c

@@ -309,10 +309,6 @@ ReturnCode picopass_device_decrypt(uint8_t* enc_data, uint8_t* dec_data) {
 ReturnCode picopass_device_parse_credential(PicopassBlock* AA1, PicopassPacs* pacs) {
     ReturnCode err;
 
-    // Thank you proxmark!
-    pacs->legacy = (memcmp(AA1[5].data, "\xff\xff\xff\xff\xff\xff\xff\xff", 8) == 0);
-    pacs->se_enabled = (memcmp(AA1[5].data, "\xff\xff\xff\x00\x06\xff\xff\xff", 8) == 0);
-
     pacs->biometrics = AA1[6].data[4];
     pacs->pin_length = AA1[6].data[6] & 0x0F;
     pacs->encryption = AA1[6].data[7];
@@ -347,6 +343,8 @@ ReturnCode picopass_device_parse_credential(PicopassBlock* AA1, PicopassPacs* pa
         FURI_LOG_D(TAG, "Unknown encryption");
     }
 
+    pacs->sio = (AA1[10].data[0] == 0x30); // rough check
+
     return ERR_NONE;
 }
 

applications/plugins/picopass/picopass_device.h

@@ -47,6 +47,7 @@ typedef struct {
 typedef struct {
     bool legacy;
     bool se_enabled;
+    bool sio;
     bool biometrics;
     uint8_t pin_length;
     PicopassEncryption encryption;

applications/plugins/picopass/picopass_worker.c

@@ -112,18 +112,12 @@ ReturnCode picopass_detect_card(int timeout) {
     return ERR_NONE;
 }
 
-ReturnCode picopass_read_card(PicopassBlock* AA1) {
+ReturnCode picopass_read_preauth(PicopassBlock* AA1) {
     rfalPicoPassIdentifyRes idRes;
     rfalPicoPassSelectRes selRes;
-    rfalPicoPassReadCheckRes rcRes;
-    rfalPicoPassCheckRes chkRes;
 
     ReturnCode err;
 
-    uint8_t div_key[8] = {0};
-    uint8_t mac[4] = {0};
-    uint8_t ccnr[12] = {0};
-
     err = rfalPicoPassPollerIdentify(&idRes);
     if(err != ERR_NONE) {
         FURI_LOG_E(TAG, "rfalPicoPassPollerIdentify error %d", err);
@@ -136,6 +130,62 @@ ReturnCode picopass_read_card(PicopassBlock* AA1) {
         return err;
     }
 
+    memcpy(AA1[PICOPASS_CSN_BLOCK_INDEX].data, selRes.CSN, sizeof(selRes.CSN));
+    FURI_LOG_D(
+        TAG,
+        "csn %02x%02x%02x%02x%02x%02x%02x%02x",
+        AA1[PICOPASS_CSN_BLOCK_INDEX].data[0],
+        AA1[PICOPASS_CSN_BLOCK_INDEX].data[1],
+        AA1[PICOPASS_CSN_BLOCK_INDEX].data[2],
+        AA1[PICOPASS_CSN_BLOCK_INDEX].data[3],
+        AA1[PICOPASS_CSN_BLOCK_INDEX].data[4],
+        AA1[PICOPASS_CSN_BLOCK_INDEX].data[5],
+        AA1[PICOPASS_CSN_BLOCK_INDEX].data[6],
+        AA1[PICOPASS_CSN_BLOCK_INDEX].data[7]);
+
+    rfalPicoPassReadBlockRes cfg = {0};
+    err = rfalPicoPassPollerReadBlock(PICOPASS_CONFIG_BLOCK_INDEX, &cfg);
+    memcpy(AA1[PICOPASS_CONFIG_BLOCK_INDEX].data, cfg.data, sizeof(cfg.data));
+    FURI_LOG_D(
+        TAG,
+        "config %02x%02x%02x%02x%02x%02x%02x%02x",
+        AA1[PICOPASS_CONFIG_BLOCK_INDEX].data[0],
+        AA1[PICOPASS_CONFIG_BLOCK_INDEX].data[1],
+        AA1[PICOPASS_CONFIG_BLOCK_INDEX].data[2],
+        AA1[PICOPASS_CONFIG_BLOCK_INDEX].data[3],
+        AA1[PICOPASS_CONFIG_BLOCK_INDEX].data[4],
+        AA1[PICOPASS_CONFIG_BLOCK_INDEX].data[5],
+        AA1[PICOPASS_CONFIG_BLOCK_INDEX].data[6],
+        AA1[PICOPASS_CONFIG_BLOCK_INDEX].data[7]);
+
+    rfalPicoPassReadBlockRes aia;
+    err = rfalPicoPassPollerReadBlock(PICOPASS_AIA_BLOCK_INDEX, &aia);
+    memcpy(AA1[PICOPASS_AIA_BLOCK_INDEX].data, aia.data, sizeof(aia.data));
+    FURI_LOG_D(
+        TAG,
+        "aia %02x%02x%02x%02x%02x%02x%02x%02x",
+        AA1[PICOPASS_AIA_BLOCK_INDEX].data[0],
+        AA1[PICOPASS_AIA_BLOCK_INDEX].data[1],
+        AA1[PICOPASS_AIA_BLOCK_INDEX].data[2],
+        AA1[PICOPASS_AIA_BLOCK_INDEX].data[3],
+        AA1[PICOPASS_AIA_BLOCK_INDEX].data[4],
+        AA1[PICOPASS_AIA_BLOCK_INDEX].data[5],
+        AA1[PICOPASS_AIA_BLOCK_INDEX].data[6],
+        AA1[PICOPASS_AIA_BLOCK_INDEX].data[7]);
+
+    return ERR_NONE;
+}
+
+ReturnCode picopass_read_card(PicopassBlock* AA1) {
+    rfalPicoPassReadCheckRes rcRes;
+    rfalPicoPassCheckRes chkRes;
+
+    ReturnCode err;
+
+    uint8_t div_key[8] = {0};
+    uint8_t mac[4] = {0};
+    uint8_t ccnr[12] = {0};
+
     err = rfalPicoPassPollerReadCheck(&rcRes);
     if(err != ERR_NONE) {
         FURI_LOG_E(TAG, "rfalPicoPassPollerReadCheck error %d", err);
@@ -143,7 +193,7 @@ ReturnCode picopass_read_card(PicopassBlock* AA1) {
     }
     memcpy(ccnr, rcRes.CCNR, sizeof(rcRes.CCNR)); // last 4 bytes left 0
 
-    loclass_diversifyKey(selRes.CSN, picopass_iclass_key, div_key);
+    loclass_diversifyKey(AA1[PICOPASS_CSN_BLOCK_INDEX].data, picopass_iclass_key, div_key);
     loclass_opt_doReaderMAC(ccnr, div_key, mac);
 
     err = rfalPicoPassPollerCheck(mac, &chkRes);
@@ -152,18 +202,11 @@ ReturnCode picopass_read_card(PicopassBlock* AA1) {
         return err;
     }
 
-    rfalPicoPassReadBlockRes csn;
-    err = rfalPicoPassPollerReadBlock(PICOPASS_CSN_BLOCK_INDEX, &csn);
-    memcpy(AA1[PICOPASS_CSN_BLOCK_INDEX].data, csn.data, sizeof(csn.data));
-
-    rfalPicoPassReadBlockRes cfg;
-    err = rfalPicoPassPollerReadBlock(PICOPASS_CONFIG_BLOCK_INDEX, &cfg);
-    memcpy(AA1[PICOPASS_CONFIG_BLOCK_INDEX].data, cfg.data, sizeof(cfg.data));
-
-    size_t app_limit = cfg.data[0] < PICOPASS_MAX_APP_LIMIT ? cfg.data[0] : PICOPASS_MAX_APP_LIMIT;
+    size_t app_limit = AA1[PICOPASS_CONFIG_BLOCK_INDEX].data[0] < PICOPASS_MAX_APP_LIMIT ?
+                           AA1[PICOPASS_CONFIG_BLOCK_INDEX].data[0] :
+                           PICOPASS_MAX_APP_LIMIT;
 
     for(size_t i = 2; i < app_limit; i++) {
-        FURI_LOG_D(TAG, "rfalPicoPassPollerReadBlock block %d", i);
         rfalPicoPassReadBlockRes block;
         err = rfalPicoPassPollerReadBlock(i, &block);
         if(err != ERR_NONE) {
@@ -287,11 +330,30 @@ void picopass_worker_detect(PicopassWorker* picopass_worker) {
     PicopassPacs* pacs = &dev_data->pacs;
     ReturnCode err;
 
+    // reset device data
+    for(size_t i = 0; i < PICOPASS_MAX_APP_LIMIT; i++) {
+        memset(AA1[i].data, 0, sizeof(AA1[i].data));
+    }
+    memset(pacs, 0, sizeof(PicopassPacs));
+
     PicopassWorkerEvent nextState = PicopassWorkerEventSuccess;
 
     while(picopass_worker->state == PicopassWorkerStateDetect) {
         if(picopass_detect_card(1000) == ERR_NONE) {
             // Process first found device
+            err = picopass_read_preauth(AA1);
+            if(err != ERR_NONE) {
+                FURI_LOG_E(TAG, "picopass_read_preauth error %d", err);
+                nextState = PicopassWorkerEventFail;
+            }
+
+            // Thank you proxmark!
+            pacs->legacy = (memcmp(AA1[5].data, "\xff\xff\xff\xff\xff\xff\xff\xff", 8) == 0);
+            pacs->se_enabled = (memcmp(AA1[5].data, "\xff\xff\xff\x00\x06\xff\xff\xff", 8) == 0);
+            if(pacs->se_enabled) {
+                FURI_LOG_D(TAG, "SE enabled");
+            }
+
             err = picopass_read_card(AA1);
             if(err != ERR_NONE) {
                 FURI_LOG_E(TAG, "picopass_read_card error %d", err);

applications/plugins/picopass/picopass_worker.h

@@ -24,6 +24,7 @@ typedef enum {
     PicopassWorkerEventSuccess,
     PicopassWorkerEventFail,
     PicopassWorkerEventNoCardDetected,
+    PicopassWorkerEventSeEnabled,
 
     PicopassWorkerEventStartReading,
 } PicopassWorkerEvent;

applications/plugins/picopass/scenes/picopass_scene_read_card_success.c

@@ -17,8 +17,10 @@ void picopass_scene_read_card_success_on_enter(void* context) {
     Picopass* picopass = context;
     string_t credential_str;
     string_t wiegand_str;
+    string_t sio_str;
     string_init(credential_str);
     string_init(wiegand_str);
+    string_init(sio_str);
 
     DOLPHIN_DEED(DolphinDeedNfcReadSuccess);
 
@@ -32,6 +34,10 @@ void picopass_scene_read_card_success_on_enter(void* context) {
     if(pacs->record.bitLength == 0) {
         string_cat_printf(wiegand_str, "Read Failed");
 
+        if(pacs->se_enabled) {
+            string_cat_printf(credential_str, "SE enabled");
+        }
+
         widget_add_button_element(
             widget,
             GuiButtonTypeLeft,
@@ -39,8 +45,6 @@ void picopass_scene_read_card_success_on_enter(void* context) {
             picopass_scene_read_card_success_widget_callback,
             picopass);
 
-        widget_add_string_element(
-            widget, 64, 12, AlignCenter, AlignCenter, FontPrimary, string_get_cstr(wiegand_str));
     } else {
         size_t bytesLength = 1 + pacs->record.bitLength / 8;
         string_set_str(credential_str, "");
@@ -55,6 +59,10 @@ void picopass_scene_read_card_success_on_enter(void* context) {
             string_cat_printf(wiegand_str, "%d bits", pacs->record.bitLength);
         }
 
+        if(pacs->sio) {
+            string_cat_printf(sio_str, "+SIO");
+        }
+
         widget_add_button_element(
             widget,
             GuiButtonTypeLeft,
@@ -68,20 +76,18 @@ void picopass_scene_read_card_success_on_enter(void* context) {
             "More",
             picopass_scene_read_card_success_widget_callback,
             picopass);
-
-        widget_add_string_element(
-            widget, 64, 12, AlignCenter, AlignCenter, FontPrimary, string_get_cstr(wiegand_str));
-        widget_add_string_element(
-            widget,
-            64,
-            32,
-            AlignCenter,
-            AlignCenter,
-            FontSecondary,
-            string_get_cstr(credential_str));
     }
+
+    widget_add_string_element(
+        widget, 64, 12, AlignCenter, AlignCenter, FontPrimary, string_get_cstr(wiegand_str));
+    widget_add_string_element(
+        widget, 64, 32, AlignCenter, AlignCenter, FontSecondary, string_get_cstr(credential_str));
+    widget_add_string_element(
+        widget, 64, 42, AlignCenter, AlignCenter, FontSecondary, string_get_cstr(sio_str));
+
     string_clear(credential_str);
     string_clear(wiegand_str);
+    string_clear(sio_str);
 
     view_dispatcher_switch_to_view(picopass->view_dispatcher, PicopassViewWidget);
 }

applications/settings/notification_settings/notification_settings_app.c

@@ -46,7 +46,7 @@ const char* const volume_text[VOLUME_COUNT] = {
 };
 const float volume_value[VOLUME_COUNT] = {0.0f, 0.25f, 0.5f, 0.75f, 1.0f};
 
-#define DELAY_COUNT 8
+#define DELAY_COUNT 11
 const char* const delay_text[DELAY_COUNT] = {
     "1s",
     "5s",
@@ -56,8 +56,23 @@ const char* const delay_text[DELAY_COUNT] = {
     "60s",
     "90s",
     "120s",
+    "5min",
+    "10min",
+    "30min",
+};
+const uint32_t delay_value[DELAY_COUNT] = {
+    1000,
+    5000,
+    10000,
+    15000,
+    30000,
+    60000,
+    90000,
+    120000,
+    300000,
+    600000,
+    1800000
 };
-const uint32_t delay_value[DELAY_COUNT] = {1000, 5000, 10000, 15000, 30000, 60000, 90000, 120000};
 
 #define VIBRO_COUNT 2
 const char* const vibro_text[VIBRO_COUNT] = {

assets/SConscript

@@ -1,5 +1,7 @@
 Import("env")
 
+from fbt.version import get_fast_git_version_id
+
 # HACHHACK
 # Currently injected to CPPPATH by libs - since they are built earlier and depend on assets
 # env.Append(
@@ -7,6 +9,7 @@ Import("env")
 #         Dir("./compiled"),
 #     ]
 # )
+version_value = Value(get_fast_git_version_id())
 
 assetsenv = env.Clone(
     tools=["fbt_assets"],
@@ -74,6 +77,7 @@ assetsenv.Alias("proto_ver", proto_ver)
 
 # Gather everything into a static lib
 assets_parts = (icons, proto, dolphin_blocking, dolphin_internal, proto_ver)
+assetsenv.Depends(assets_parts, version_value)
 
 assetslib = assetsenv.Library("${FW_LIB_NAME}", assets_parts)
 assetsenv.Install("${LIB_DIST_DIR}", assetslib)

assets/dolphin/external/L3_Fireplace_128x64/meta.txt

@@ -0,0 +1,14 @@
+Filetype: Flipper Animation
+Version: 1
+
+Width: 128
+Height: 64
+Passive frames: 8
+Active frames: 0
+Frames order: 0 1 2 3 4 5 6 7
+Active cycles: 0
+Frame rate: 4
+Duration: 3600
+Active cooldown: 0
+
+Bubble slots: 0

assets/dolphin/external/manifest.txt

@@ -99,6 +99,13 @@ Min level: 3
 Max level: 3
 Weight: 3
 
+Name: L3_Fireplace_128x64
+Min butthurt: 0
+Max butthurt: 13
+Min level: 2
+Max level: 3
+Weight: 3
+
 Name: L2_Soldering_128x64
 Min butthurt: 0
 Max butthurt: 10

assets/resources/dolphin/L3_Fireplace_128x64/meta.txt

@@ -0,0 +1,14 @@
+Filetype: Flipper Animation
+Version: 1
+
+Width: 128
+Height: 64
+Passive frames: 8
+Active frames: 0
+Frames order: 0 1 2 3 4 5 6 7
+Active cycles: 0
+Frame rate: 4
+Duration: 3600
+Active cooldown: 0
+
+Bubble slots: 0

assets/resources/dolphin/manifest.txt

@@ -561,6 +561,13 @@ Min level: 1
 Max level: 30
 Weight: 4
 
+Name: L3_Fireplace_128x64
+Min butthurt: 0
+Max butthurt: 13
+Min level: 2
+Max level: 3
+Weight: 3
+
 Name: L2_Soldering_128x64
 Min butthurt: 0
 Max butthurt: 10

documentation/HowToInstall.md

@@ -24,9 +24,6 @@
 `update/f7-update-(CURRENT VERSION)/update.fuf`
 - Update will start, wait for all stages, and when flipper started after update, you can upload any custom [IR libs](https://github.com/logickworkshop/Flipper-IRDB), and other stuff using qFlipper or directly into microSD card
 
-<br>
-<br>
-
 ## With qFlipper
 
 ### **Replace (CURRENT VERSION) with version that you downloaded from releases**
@@ -62,4 +59,3 @@ then select **`flipper-z-f7-full-(CURRENT VERSION).dfu`**
 - ### If you installed using .dfu - unpack files from archive `sd-card-(CURRENT VERSION).zip` to your microSD card
 <br>
 
-- ## [How To: Configure UniversalRF Remix App](https://github.com/RogueMaster/flipperzero-firmware-wPlugins/blob/420/documentation/UniRFRemix.md)

firmware/targets/f7/api_symbols.csv

@@ -113,7 +113,12 @@ Header,+,lib/drivers/nrf24.h,,
 Header,+,lib/flipper_application/flipper_application.h,,
 Header,+,lib/flipper_format/flipper_format.h,,
 Header,+,lib/flipper_format/flipper_format_i.h,,
+Header,+,lib/lfrfid/lfrfid_dict_file.h,,
+Header,+,lib/lfrfid/lfrfid_raw_file.h,,
+Header,+,lib/lfrfid/lfrfid_raw_worker.h,,
 Header,+,lib/lfrfid/lfrfid_worker.h,,
+Header,+,lib/lfrfid/protocols/lfrfid_protocols.h,,
+Header,+,lib/lfrfid/tools/bit_lib.h,,
 Header,+,lib/micro-ecc/uECC.h,,
 Header,+,lib/one_wire/ibutton/ibutton_worker.h,,
 Header,+,lib/one_wire/maxim_crc.h,,
@@ -477,6 +482,26 @@ Function,-,atomo_encrypt,void,uint8_t*
 Function,-,basename,char*,const char*
 Function,-,bcmp,int,"const void*, const void*, size_t"
 Function,-,bcopy,void,"const void*, void*, size_t"
+Function,+,bit_lib_add_parity,size_t,"const uint8_t*, size_t, uint8_t*, size_t, uint8_t, uint8_t, BitLibParity"
+Function,+,bit_lib_copy_bits,void,"uint8_t*, size_t, size_t, const uint8_t*, size_t"
+Function,+,bit_lib_crc16,uint16_t,"const uint8_t*, size_t, uint16_t, uint16_t, _Bool, _Bool, uint16_t"
+Function,+,bit_lib_crc8,uint16_t,"const uint8_t*, size_t, uint8_t, uint8_t, _Bool, _Bool, uint8_t"
+Function,+,bit_lib_get_bit,_Bool,"const uint8_t*, size_t"
+Function,+,bit_lib_get_bit_count,uint8_t,uint32_t
+Function,+,bit_lib_get_bits,uint8_t,"const uint8_t*, size_t, uint8_t"
+Function,+,bit_lib_get_bits_16,uint16_t,"const uint8_t*, size_t, uint8_t"
+Function,+,bit_lib_get_bits_32,uint32_t,"const uint8_t*, size_t, uint8_t"
+Function,+,bit_lib_print_bits,void,"const uint8_t*, size_t"
+Function,+,bit_lib_print_regions,void,"const BitLibRegion*, size_t, const uint8_t*, size_t"
+Function,+,bit_lib_push_bit,void,"uint8_t*, size_t, _Bool"
+Function,+,bit_lib_remove_bit_every_nth,size_t,"uint8_t*, size_t, uint8_t, uint8_t"
+Function,+,bit_lib_reverse_16_fast,uint16_t,uint16_t
+Function,+,bit_lib_reverse_8_fast,uint8_t,uint8_t
+Function,+,bit_lib_reverse_bits,void,"uint8_t*, size_t, uint8_t"
+Function,+,bit_lib_set_bit,void,"uint8_t*, size_t, _Bool"
+Function,+,bit_lib_set_bits,void,"uint8_t*, size_t, uint8_t, uint8_t"
+Function,+,bit_lib_test_parity,_Bool,"const uint8_t*, size_t, uint8_t, BitLibParity, uint8_t"
+Function,+,bit_lib_test_parity_32,_Bool,"uint32_t, BitLibParity"
 Function,+,ble_app_get_key_storage_buff,void,"uint8_t**, uint16_t*"
 Function,+,ble_app_init,_Bool,
 Function,+,ble_app_thread_stop,void,
@@ -1128,7 +1153,6 @@ Function,+,furi_hal_power_get_battery_remaining_capacity,uint32_t,
 Function,+,furi_hal_power_get_battery_temperature,float,FuriHalPowerIC
 Function,+,furi_hal_power_get_battery_voltage,float,FuriHalPowerIC
 Function,+,furi_hal_power_get_pct,uint8_t,
-Function,-,furi_hal_power_get_system_voltage,float,
 Function,+,furi_hal_power_get_usb_voltage,float,
 Function,+,furi_hal_power_info_get,void,"FuriHalPowerInfoCallback, void*"
 Function,-,furi_hal_power_init,void,
@@ -1503,6 +1527,21 @@ Function,-,ldexp,double,"double, int"
 Function,-,ldexpf,float,"float, int"
 Function,-,ldexpl,long double,"long double, int"
 Function,-,ldiv,ldiv_t,"long, long"
+Function,+,lfrfid_dict_file_load,ProtocolId,"ProtocolDict*, const char*"
+Function,+,lfrfid_dict_file_save,_Bool,"ProtocolDict*, ProtocolId, const char*"
+Function,+,lfrfid_raw_file_alloc,LFRFIDRawFile*,Storage*
+Function,+,lfrfid_raw_file_free,void,LFRFIDRawFile*
+Function,+,lfrfid_raw_file_open_read,_Bool,"LFRFIDRawFile*, const char*"
+Function,+,lfrfid_raw_file_open_write,_Bool,"LFRFIDRawFile*, const char*"
+Function,+,lfrfid_raw_file_read_header,_Bool,"LFRFIDRawFile*, float*, float*"
+Function,+,lfrfid_raw_file_read_pair,_Bool,"LFRFIDRawFile*, uint32_t*, uint32_t*, _Bool*"
+Function,+,lfrfid_raw_file_write_buffer,_Bool,"LFRFIDRawFile*, uint8_t*, size_t"
+Function,+,lfrfid_raw_file_write_header,_Bool,"LFRFIDRawFile*, float, float, uint32_t"
+Function,+,lfrfid_raw_worker_alloc,LFRFIDRawWorker*,
+Function,+,lfrfid_raw_worker_free,void,LFRFIDRawWorker*
+Function,+,lfrfid_raw_worker_start_emulate,void,"LFRFIDRawWorker*, const char*, LFRFIDWorkerEmulateRawCallback, void*"
+Function,+,lfrfid_raw_worker_start_read,void,"LFRFIDRawWorker*, const char*, float, float, LFRFIDWorkerReadRawCallback, void*"
+Function,+,lfrfid_raw_worker_stop,void,LFRFIDRawWorker*
 Function,+,lfrfid_worker_alloc,LFRFIDWorker*,ProtocolDict*
 Function,-,lfrfid_worker_emulate_raw_start,void,"LFRFIDWorker*, const char*, LFRFIDWorkerEmulateRawCallback, void*"
 Function,+,lfrfid_worker_emulate_start,void,"LFRFIDWorker*, LFRFIDProtocol"
@@ -2626,7 +2665,6 @@ Function,-,subghz_protocol_faac_slh_create_data,_Bool,"void*, FlipperFormat*, ui
 Function,-,subghz_protocol_keeloq_bft_create_data,_Bool,"void*, FlipperFormat*, uint32_t, uint8_t, uint16_t, uint32_t, const char*, SubGhzPresetDefinition*"
 Function,-,subghz_protocol_keeloq_create_data,_Bool,"void*, FlipperFormat*, uint32_t, uint8_t, uint16_t, const char*, SubGhzPresetDefinition*"
 Function,-,subghz_protocol_nice_flor_s_encrypt,uint64_t,"uint64_t, const char*"
-Function,-,subghz_protocol_raw_file_encoder_worker_callback_end,void,void*
 Function,-,subghz_protocol_raw_file_encoder_worker_set_callback_end,void,"SubGhzProtocolEncoderRAW*, SubGhzProtocolEncoderRAWCallbackEnd, void*"
 Function,+,subghz_protocol_raw_gen_fff_data,void,"FlipperFormat*, const char*"
 Function,-,subghz_protocol_raw_get_sample_write,size_t,SubGhzProtocolDecoderRAW*

firmware/targets/furi_hal_include/furi_hal_power.h

@@ -156,12 +156,6 @@ float furi_hal_power_get_battery_current(FuriHalPowerIC ic);
  */
 float furi_hal_power_get_battery_temperature(FuriHalPowerIC ic);
 
-/** Get System voltage in V
- *
- * @return     voltage in V
- */
-float furi_hal_power_get_system_voltage();
-
 /** Get USB voltage in V
  *
  * @return     voltage in V

lib/lfrfid/SConscript

@@ -9,6 +9,11 @@ env.Append(
     ],
     SDK_HEADERS=[
         File("#/lib/lfrfid/lfrfid_worker.h"),
+        File("#/lib/lfrfid/lfrfid_raw_worker.h"),
+        File("#/lib/lfrfid/lfrfid_raw_file.h"),
+        File("#/lib/lfrfid/lfrfid_dict_file.h"),
+        File("#/lib/lfrfid/tools/bit_lib.h"),
+        File("#/lib/lfrfid/protocols/lfrfid_protocols.h"),
     ],
 )
 

lib/mbedtls.scons

@@ -11,6 +11,14 @@ env.Append(
 libenv = env.Clone(FW_LIB_NAME="mbedtls")
 libenv.ApplyLibFlags()
 
+libenv.AppendUnique(
+    CCFLAGS=[
+        # Required for lib to be linkable with .faps
+        "-mword-relocations",
+        "-mlong-calls",
+    ],
+)
+
 sources = [
     "mbedtls/library/des.c",
     "mbedtls/library/sha1.c",

lib/nfc/helpers/reader_analyzer.c

@@ -3,6 +3,7 @@
 #include <lib/nfc/protocols/nfc_util.h>
 #include <lib/nfc/protocols/mifare_classic.h>
 #include <m-array.h>
+#include <furi_hal_random.h>
 
 #include "mfkey32.h"
 #include "nfc_debug_pcap.h"
@@ -38,7 +39,7 @@ struct ReaderAnalyzer {
     NfcDebugPcap* pcap;
 };
 
-const FuriHalNfcDevData reader_analyzer_nfc_data[] = {
+static FuriHalNfcDevData reader_analyzer_nfc_data[] = { //XXX
     [ReaderAnalyzerNfcDataMfClassic] =
         {.sak = 0x08,
          .atqa = {0x44, 0x00},
@@ -99,7 +100,8 @@ int32_t reader_analyzer_thread(void* context) {
 
 ReaderAnalyzer* reader_analyzer_alloc() {
     ReaderAnalyzer* instance = malloc(sizeof(ReaderAnalyzer));
-
+    reader_analyzer_nfc_data[ReaderAnalyzerNfcDataMfClassic].cuid = rand(); //XXX
+    furi_hal_random_fill_buf((uint8_t*) &reader_analyzer_nfc_data[ReaderAnalyzerNfcDataMfClassic].uid, 7);
     instance->nfc_data = reader_analyzer_nfc_data[ReaderAnalyzerNfcDataMfClassic];
     instance->alive = false;
     instance->stream =

lib/subghz/protocols/raw.h

@@ -4,12 +4,12 @@
 
 #include <furi_hal.h>
 
+#define SUBGHZ_PROTOCOL_RAW_NAME "RAW"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#define SUBGHZ_PROTOCOL_RAW_NAME "RAW"
-
 typedef void (*SubGhzProtocolEncoderRAWCallbackEnd)(void* context);
 
 typedef struct SubGhzProtocolDecoderRAW SubGhzProtocolDecoderRAW;
@@ -142,12 +142,6 @@ void subghz_protocol_encoder_raw_free(void* context);
  */
 void subghz_protocol_encoder_raw_stop(void* context);
 
-/**
- * Сallback on completion of file transfer.
- * @param context Pointer to a SubGhzProtocolEncoderRAW instance
- */
-void subghz_protocol_raw_file_encoder_worker_callback_end(void* context);
-
 /**
  * Set callback on completion of file transfer.
  * @param instance Pointer to a SubGhzProtocolEncoderRAW instance

site_scons/fbt/sdk.py

@@ -484,20 +484,22 @@ class SdkCache:
                     break
         self.loaded_dirty = bool(self.new_entries)
 
-    def sync_sets(self, known_set: Set[Any], new_set: Set[Any]):
+    def sync_sets(
+        self, known_set: Set[Any], new_set: Set[Any], update_version: bool = True
+    ):
         new_entries = new_set - known_set
         if new_entries:
             print(f"New: {new_entries}")
             known_set |= new_entries
             self.new_entries |= new_entries
-            if self.version_action == VersionBump.NONE:
+            if update_version and self.version_action == VersionBump.NONE:
                 self.version_action = VersionBump.MINOR
         removed_entries = known_set - new_set
         if removed_entries:
             print(f"Removed: {removed_entries}")
             known_set -= removed_entries
-            # If any of removed entries was part of active API, that's a major bump
-            if any(
+            # If any of removed entries was a part of active API, that's a major bump
+            if update_version and any(
                 filter(
                     lambda e: e not in self.disabled_entries
                     and e not in self.new_entries,
@@ -509,6 +511,6 @@ class SdkCache:
             self.new_entries -= removed_entries
 
     def validate_api(self, api: ApiEntries) -> None:
-        self.sync_sets(self.sdk.headers, api.headers)
+        self.sync_sets(self.sdk.headers, api.headers, False)
         self.sync_sets(self.sdk.functions, api.functions)
         self.sync_sets(self.sdk.variables, api.variables)

site_scons/fbt/version.py

@@ -1,7 +1,9 @@
 import subprocess
 import datetime
+from functools import cache
 
 
+@cache
 def get_fast_git_version_id():
     try:
         version = (