Merge branch 'Next-Flip:dev' into dev

applications/system/js_app/application.fam

@@ -94,3 +94,10 @@ App(
     requires=["js_app"],
     sources=["modules/js_keyboard.c"],
 )
+App(
+    appid="js_subghz",
+    apptype=FlipperAppType.PLUGIN,
+    entry_point="js_subghz_ep",
+    requires=["js_app"],
+    sources=["modules/js_subghz/*.c"],
+)

applications/system/js_app/examples/apps/Scripts/blebeacon.js

@@ -1,4 +1,15 @@
 let blebeacon = require("blebeacon");
+
+// Stop if previous background beacon is active
+if (blebeacon.isActive()) {
+    blebeacon.stop();
+}
+
+// Make sure it resets at script exit, true will keep advertising in background
+// This is false by default, can be omitted
+blebeacon.keepAlive(false);
+
+
 let math = require("math");
 
 let currentIndex = 0;
@@ -43,9 +54,6 @@ function sendRandomModelAdvertisement() {
     blebeacon.stop();
 }
 
-// Make sure it resets at script exit, true will keep advertising in background
-blebeacon.keepAlive(true);
-
 while (true) {
     sendRandomModelAdvertisement();
 }

applications/system/js_app/examples/apps/Scripts/subghz.js

@@ -0,0 +1,37 @@
+let subghz = require("subghz");
+subghz.setup();
+
+function printRXline() {
+    if (subghz.getState() !== "RX") {
+        subghz.setRx(); // to RX
+    }
+
+    let rssi = subghz.getRssi();
+    let freq = subghz.getFrequency();
+    let ext = subghz.isExternal();
+
+    print("rssi: ", rssi, "dBm", "@", freq, "MHz", "ext: ", ext);
+}
+
+function changeFrequency(freq) {
+    if (subghz.getState() !== "IDLE") {
+        subghz.setIdle(); // need to be idle to change frequency
+    }
+    subghz.setFrequency(freq);
+}
+
+subghz.setIdle();
+print(subghz.getState()); // "IDLE"
+subghz.setRx();
+print(subghz.getState()); // "RX"
+
+changeFrequency(433920000);
+printRXline();
+delay(1000);
+
+let result = subghz.transmitFile("/ext/subghz/0.sub");
+print(result ? "Send success" : "Send failed");
+delay(1000);
+
+changeFrequency(315000000);
+printRXline();

applications/system/js_app/modules/js_blebeacon.c

@@ -29,6 +29,11 @@ static void ret_bad_args(struct mjs* mjs, const char* error) {
     mjs_return(mjs, MJS_UNDEFINED);
 }
 
+static void ret_int_err(struct mjs* mjs, const char* error) {
+    mjs_prepend_errorf(mjs, MJS_INTERNAL_ERROR, "%s", error);
+    mjs_return(mjs, MJS_UNDEFINED);
+}
+
 static bool check_arg_count(struct mjs* mjs, size_t count) {
     size_t num_args = mjs_nargs(mjs);
     if(num_args != count) {
@@ -48,6 +53,14 @@ static bool get_int_arg(struct mjs* mjs, size_t index, uint8_t* value, bool erro
     return true;
 }
 
+static void js_blebeacon_is_active(struct mjs* mjs) {
+    JsBlebeaconInst* blebeacon = get_this_ctx(mjs);
+    if(!check_arg_count(mjs, 0)) return;
+    UNUSED(blebeacon);
+
+    mjs_return(mjs, mjs_mk_boolean(mjs, furi_hal_bt_extra_beacon_is_active()));
+}
+
 static void js_blebeacon_set_config(struct mjs* mjs) {
     JsBlebeaconInst* blebeacon = get_this_ctx(mjs);
     if(mjs_nargs(mjs) < 1 || mjs_nargs(mjs) > 4) {
@@ -100,7 +113,12 @@ static void js_blebeacon_set_config(struct mjs* mjs) {
             blebeacon->prev_cfg_set = false;
         }
     }
-    furi_check(furi_hal_bt_extra_beacon_set_config(&config));
+    if(!furi_hal_bt_extra_beacon_set_config(&config)) {
+        ret_int_err(mjs, "Failed setting beacon config");
+        return;
+    }
+
+    mjs_return(mjs, MJS_UNDEFINED);
 }
 
 static void js_blebeacon_set_data(struct mjs* mjs) {
@@ -125,7 +143,10 @@ static void js_blebeacon_set_data(struct mjs* mjs) {
         blebeacon->saved_prev_data = true;
         blebeacon->prev_data_len = furi_hal_bt_extra_beacon_get_data(blebeacon->prev_data);
     }
-    furi_check(furi_hal_bt_extra_beacon_set_data((uint8_t*)data, data_len));
+    if(!furi_hal_bt_extra_beacon_set_data((uint8_t*)data, data_len)) {
+        ret_int_err(mjs, "Failed setting beacon data");
+        return;
+    }
 
     mjs_return(mjs, MJS_UNDEFINED);
 }
@@ -138,7 +159,10 @@ static void js_blebeacon_start(struct mjs* mjs) {
         blebeacon->saved_prev_active = true;
         blebeacon->prev_active = furi_hal_bt_extra_beacon_is_active();
     }
-    furi_check(furi_hal_bt_extra_beacon_start());
+    if(!furi_hal_bt_extra_beacon_start()) {
+        ret_int_err(mjs, "Failed starting beacon");
+        return;
+    }
 
     mjs_return(mjs, MJS_UNDEFINED);
 }
@@ -148,6 +172,10 @@ static void js_blebeacon_stop(struct mjs* mjs) {
     if(!check_arg_count(mjs, 0)) return;
     UNUSED(blebeacon);
 
+    if(!blebeacon->saved_prev_active) {
+        blebeacon->saved_prev_active = true;
+        blebeacon->prev_active = furi_hal_bt_extra_beacon_is_active();
+    }
     furi_hal_bt_extra_beacon_stop();
 
     mjs_return(mjs, MJS_UNDEFINED);
@@ -167,6 +195,7 @@ static void* js_blebeacon_create(struct mjs* mjs, mjs_val_t* object) {
     JsBlebeaconInst* blebeacon = malloc(sizeof(JsBlebeaconInst));
     mjs_val_t blebeacon_obj = mjs_mk_object(mjs);
     mjs_set(mjs, blebeacon_obj, INST_PROP_NAME, ~0, mjs_mk_foreign(mjs, blebeacon));
+    mjs_set(mjs, blebeacon_obj, "isActive", ~0, MJS_MK_FN(js_blebeacon_is_active));
     mjs_set(mjs, blebeacon_obj, "setConfig", ~0, MJS_MK_FN(js_blebeacon_set_config));
     mjs_set(mjs, blebeacon_obj, "setData", ~0, MJS_MK_FN(js_blebeacon_set_data));
     mjs_set(mjs, blebeacon_obj, "start", ~0, MJS_MK_FN(js_blebeacon_start));

applications/system/js_app/modules/js_subghz/js_subghz.c

@@ -0,0 +1,391 @@
+#include "../../js_modules.h"
+#include "radio_device_loader.h"
+
+#include <lib/subghz/transmitter.h>
+#include <lib/subghz/devices/devices.h>
+#include <lib/subghz/protocols/protocol_items.h>
+
+#include <flipper_format/flipper_format_i.h>
+
+#define tag "js_subghz"
+
+typedef enum {
+    JsSubghzRadioStateRX,
+    JsSubghzRadioStateTX,
+    JsSubghzRadioStateIDLE,
+} JsSubghzRadioState;
+
+typedef struct {
+    const SubGhzDevice* radio_device;
+    int frequency;
+    bool is_external;
+    JsSubghzRadioState state;
+} JsSubghzInst;
+
+// from subghz cli
+static FuriHalSubGhzPreset js_subghz_get_preset_name(const char* preset_name) {
+    FuriHalSubGhzPreset preset = FuriHalSubGhzPresetIDLE;
+    if(!strcmp(preset_name, "FuriHalSubGhzPresetOok270Async")) {
+        preset = FuriHalSubGhzPresetOok270Async;
+    } else if(!strcmp(preset_name, "FuriHalSubGhzPresetOok650Async")) {
+        preset = FuriHalSubGhzPresetOok650Async;
+    } else if(!strcmp(preset_name, "FuriHalSubGhzPreset2FSKDev238Async")) {
+        preset = FuriHalSubGhzPreset2FSKDev238Async;
+    } else if(!strcmp(preset_name, "FuriHalSubGhzPreset2FSKDev476Async")) {
+        preset = FuriHalSubGhzPreset2FSKDev476Async;
+    } else if(!strcmp(preset_name, "FuriHalSubGhzPresetCustom")) {
+        preset = FuriHalSubGhzPresetCustom;
+    } else {
+        FURI_LOG_I(tag, "unknown preset");
+    }
+    return preset;
+}
+
+static int32_t get_int_arg(struct mjs* mjs, size_t index, int32_t* value) {
+    mjs_val_t int_obj = mjs_arg(mjs, index);
+    if(!mjs_is_number(int_obj)) {
+        mjs_prepend_errorf(mjs, MJS_BAD_ARGS_ERROR, "Argument must be a number");
+        mjs_return(mjs, MJS_UNDEFINED);
+        return false;
+    }
+    *value = mjs_get_int(mjs, int_obj);
+    return true;
+}
+
+static void js_subghz_set_rx(struct mjs* mjs) {
+    mjs_val_t obj_inst = mjs_get(mjs, mjs_get_this(mjs), INST_PROP_NAME, ~0);
+    JsSubghzInst* js_subghz = mjs_get_ptr(mjs, obj_inst);
+    furi_assert(js_subghz);
+
+    if(js_subghz->state == JsSubghzRadioStateRX) {
+        mjs_return(mjs, MJS_UNDEFINED);
+        return;
+    }
+
+    subghz_devices_set_rx(js_subghz->radio_device);
+    js_subghz->state = JsSubghzRadioStateRX;
+}
+
+static void js_subgjz_set_idle(struct mjs* mjs) {
+    mjs_val_t obj_inst = mjs_get(mjs, mjs_get_this(mjs), INST_PROP_NAME, ~0);
+    JsSubghzInst* js_subghz = mjs_get_ptr(mjs, obj_inst);
+    furi_assert(js_subghz);
+
+    if(js_subghz->state == JsSubghzRadioStateIDLE) {
+        mjs_return(mjs, MJS_UNDEFINED);
+        return;
+    }
+
+    subghz_devices_idle(js_subghz->radio_device);
+    js_subghz->state = JsSubghzRadioStateIDLE;
+}
+
+static void js_subghz_get_rssi(struct mjs* mjs) {
+    mjs_val_t obj_inst = mjs_get(mjs, mjs_get_this(mjs), INST_PROP_NAME, ~0);
+    JsSubghzInst* js_subghz = mjs_get_ptr(mjs, obj_inst);
+    furi_assert(js_subghz);
+
+    if(js_subghz->state != JsSubghzRadioStateRX) {
+        mjs_return(mjs, MJS_UNDEFINED);
+        return;
+    }
+
+    float rssi = subghz_devices_get_rssi(js_subghz->radio_device);
+    mjs_return(mjs, mjs_mk_number(mjs, (double)rssi));
+}
+
+static void js_subghz_get_state(struct mjs* mjs) {
+    mjs_val_t obj_inst = mjs_get(mjs, mjs_get_this(mjs), INST_PROP_NAME, ~0);
+    JsSubghzInst* js_subghz = mjs_get_ptr(mjs, obj_inst);
+    furi_assert(js_subghz);
+
+    const char* state;
+    switch(js_subghz->state) {
+    case JsSubghzRadioStateRX:
+        state = "RX";
+        break;
+    case JsSubghzRadioStateTX:
+        state = "TX";
+        break;
+    case JsSubghzRadioStateIDLE:
+        state = "IDLE";
+        break;
+    default:
+        state = "";
+        break;
+    }
+
+    mjs_return(mjs, mjs_mk_string(mjs, state, ~0, true));
+}
+
+static void js_subghz_is_external(struct mjs* mjs) {
+    mjs_val_t obj_inst = mjs_get(mjs, mjs_get_this(mjs), INST_PROP_NAME, ~0);
+    JsSubghzInst* js_subghz = mjs_get_ptr(mjs, obj_inst);
+    furi_assert(js_subghz);
+
+    mjs_return(mjs, mjs_mk_boolean(mjs, js_subghz->is_external));
+}
+
+static void js_subghz_set_frequency(struct mjs* mjs) {
+    mjs_val_t obj_inst = mjs_get(mjs, mjs_get_this(mjs), INST_PROP_NAME, ~0);
+    JsSubghzInst* js_subghz = mjs_get_ptr(mjs, obj_inst);
+    furi_assert(js_subghz);
+
+    if(js_subghz->state != JsSubghzRadioStateIDLE) {
+        mjs_prepend_errorf(mjs, MJS_INTERNAL_ERROR, "Radio is not in IDLE state");
+        mjs_return(mjs, MJS_UNDEFINED);
+        return;
+    }
+
+    int32_t frequency;
+    if(!get_int_arg(mjs, 0, &frequency)) return;
+
+    if(!subghz_devices_is_frequency_valid(js_subghz->radio_device, frequency)) {
+        mjs_prepend_errorf(mjs, MJS_INTERNAL_ERROR, "Invalid frequency");
+        mjs_return(mjs, MJS_UNDEFINED);
+        return;
+    }
+
+    js_subghz->frequency = subghz_devices_set_frequency(js_subghz->radio_device, frequency);
+
+    mjs_return(mjs, mjs_mk_number(mjs, (double)js_subghz->frequency));
+}
+
+static void js_subghz_get_frequency(struct mjs* mjs) {
+    mjs_val_t obj_inst = mjs_get(mjs, mjs_get_this(mjs), INST_PROP_NAME, ~0);
+    JsSubghzInst* js_subghz = mjs_get_ptr(mjs, obj_inst);
+    furi_assert(js_subghz);
+
+    mjs_return(mjs, mjs_mk_number(mjs, (double)js_subghz->frequency));
+}
+
+static void js_subghz_transmit_file(struct mjs* mjs) {
+    mjs_val_t obj_inst = mjs_get(mjs, mjs_get_this(mjs), INST_PROP_NAME, ~0);
+    JsSubghzInst* js_subghz = mjs_get_ptr(mjs, obj_inst);
+    furi_assert(js_subghz);
+
+    mjs_val_t file = mjs_arg(mjs, 0);
+
+    if(!mjs_is_string(file)) {
+        mjs_prepend_errorf(mjs, MJS_INTERNAL_ERROR, "File must be a string");
+        mjs_return(mjs, MJS_UNDEFINED);
+        return;
+    }
+
+    const char* file_path = mjs_get_string(mjs, &file, NULL);
+    if(!file_path) {
+        mjs_prepend_errorf(mjs, MJS_INTERNAL_ERROR, "Failed to get file path");
+        mjs_return(mjs, MJS_UNDEFINED);
+        return;
+    }
+
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+    FlipperFormat* fff_file = flipper_format_file_alloc(storage);
+    FlipperFormat* fff_data_raw = flipper_format_string_alloc();
+
+    if(!flipper_format_file_open_existing(fff_file, file_path)) {
+        flipper_format_free(fff_file);
+        furi_record_close(RECORD_STORAGE);
+        mjs_prepend_errorf(mjs, MJS_INTERNAL_ERROR, "Failed to open file");
+        mjs_return(mjs, MJS_UNDEFINED);
+        return;
+    }
+
+    SubGhzEnvironment* environment = subghz_environment_alloc();
+    if(!subghz_environment_load_keystore(environment, SUBGHZ_KEYSTORE_DIR_NAME)) {
+        FURI_LOG_I(tag, "Load_keystore keeloq_mfcodes \033[0;31mERROR\033[0m\r\n");
+    }
+    if(!subghz_environment_load_keystore(environment, SUBGHZ_KEYSTORE_DIR_USER_NAME)) {
+        FURI_LOG_I(tag, "Load_keystore keeloq_mfcodes_user \033[0;33mAbsent\033[0m\r\n");
+    }
+    subghz_environment_set_alutech_at_4n_rainbow_table_file_name(
+        environment, SUBGHZ_ALUTECH_AT_4N_DIR_NAME);
+    subghz_environment_set_nice_flor_s_rainbow_table_file_name(
+        environment, SUBGHZ_NICE_FLOR_S_DIR_NAME);
+    subghz_environment_set_protocol_registry(environment, (void*)&subghz_protocol_registry);
+
+    FuriString* temp_str = furi_string_alloc();
+    SubGhzTransmitter* transmitter = NULL;
+    bool is_init_protocol = true;
+    bool is_sent = false;
+    uint32_t frequency = 0;
+    uint32_t repeat = 10;
+
+    do {
+        //Load frequency
+        if(!flipper_format_read_uint32(fff_file, "Frequency", &frequency, 1)) {
+            mjs_prepend_errorf(mjs, MJS_INTERNAL_ERROR, "Failed to read frequency from file");
+            mjs_return(mjs, MJS_UNDEFINED);
+            break;
+        }
+
+        if(!subghz_devices_is_frequency_valid(js_subghz->radio_device, frequency)) {
+            mjs_prepend_errorf(mjs, MJS_INTERNAL_ERROR, "Invalid frequency");
+            mjs_return(mjs, MJS_UNDEFINED);
+            break;
+        }
+
+        if(!flipper_format_read_string(fff_file, "Preset", temp_str)) {
+            mjs_prepend_errorf(mjs, MJS_INTERNAL_ERROR, "Failed to read preset from file");
+            mjs_return(mjs, MJS_UNDEFINED);
+            break;
+        }
+
+        subghz_devices_reset(js_subghz->radio_device);
+
+        if(!strcmp(furi_string_get_cstr(temp_str), "FuriHalSubGhzPresetCustom")) {
+            mjs_prepend_errorf(mjs, MJS_INTERNAL_ERROR, "Custom presets are not supported (yet)");
+            mjs_return(mjs, MJS_UNDEFINED);
+            break;
+        } else {
+            subghz_devices_load_preset(
+                js_subghz->radio_device,
+                js_subghz_get_preset_name(furi_string_get_cstr(temp_str)),
+                NULL);
+        }
+
+        js_subghz->frequency = subghz_devices_set_frequency(js_subghz->radio_device, frequency);
+
+        if(!flipper_format_read_string(fff_file, "Protocol", temp_str)) {
+            mjs_prepend_errorf(mjs, MJS_INTERNAL_ERROR, "Failed to read protocol from file");
+            mjs_return(mjs, MJS_UNDEFINED);
+            break;
+        }
+
+        SubGhzProtocolStatus status;
+        bool is_raw = false;
+
+        if(!strcmp(furi_string_get_cstr(temp_str), "RAW")) {
+            subghz_protocol_raw_gen_fff_data(
+                fff_data_raw, file_path, subghz_devices_get_name(js_subghz->radio_device));
+            is_raw = true;
+        }
+
+        transmitter = subghz_transmitter_alloc_init(environment, furi_string_get_cstr(temp_str));
+        if(transmitter == NULL) {
+            is_init_protocol = false;
+        }
+
+        if(is_init_protocol) {
+            status = subghz_transmitter_deserialize(transmitter, is_raw ? fff_data_raw : fff_file);
+            if(status != SubGhzProtocolStatusOk) {
+                FURI_LOG_I(tag, "failed to deserialize transmitter");
+                is_init_protocol = false;
+            }
+        } else {
+            FURI_LOG_I(tag, "failed to allocate transmitter");
+            subghz_devices_idle(js_subghz->radio_device);
+            js_subghz->state = JsSubghzRadioStateIDLE;
+        }
+    } while(false);
+
+    if(is_init_protocol) {
+        if(!js_subghz->is_external) {
+            furi_hal_power_suppress_charge_enter();
+        }
+
+        FURI_LOG_I(tag, "transmitting file %s", file_path);
+
+        do {
+            furi_delay_ms(200);
+            if(subghz_devices_start_async_tx(
+                   js_subghz->radio_device, subghz_transmitter_yield, transmitter)) {
+                while(!subghz_devices_is_async_complete_tx(js_subghz->radio_device)) {
+                    furi_delay_ms(333);
+                }
+                subghz_devices_stop_async_tx(js_subghz->radio_device);
+                is_sent = true;
+            } else {
+                FURI_LOG_E(tag, "failed to start async tx");
+            }
+
+        } while(repeat && !strcmp(furi_string_get_cstr(temp_str), "RAW"));
+
+        subghz_devices_idle(js_subghz->radio_device);
+        js_subghz->state = JsSubghzRadioStateIDLE;
+
+        if(!js_subghz->is_external) {
+            furi_hal_power_suppress_charge_exit();
+        }
+    }
+
+    furi_string_free(temp_str);
+    flipper_format_free(fff_file);
+    flipper_format_free(fff_data_raw);
+    furi_record_close(RECORD_STORAGE);
+
+    subghz_environment_reset_keeloq(environment);
+    subghz_environment_free(environment);
+    subghz_transmitter_free(transmitter);
+
+    mjs_return(mjs, mjs_mk_boolean(mjs, is_sent));
+}
+
+static void js_subghz_setup(struct mjs* mjs) {
+    mjs_val_t obj_inst = mjs_get(mjs, mjs_get_this(mjs), INST_PROP_NAME, ~0);
+    JsSubghzInst* js_subghz = mjs_get_ptr(mjs, obj_inst);
+    furi_assert(js_subghz);
+
+    js_subghz->radio_device =
+        radio_device_loader_set(js_subghz->radio_device, SubGhzRadioDeviceTypeExternalCC1101);
+
+    if(!subghz_devices_is_connect(js_subghz->radio_device)) {
+        js_subghz->is_external = true;
+    } else {
+        js_subghz->is_external = false;
+    }
+
+    js_subghz->state = JsSubghzRadioStateIDLE;
+    js_subghz->frequency = 433920000;
+
+    subghz_devices_reset(js_subghz->radio_device);
+    subghz_devices_idle(js_subghz->radio_device);
+
+    mjs_return(mjs, MJS_UNDEFINED);
+}
+
+static void* js_subghz_create(struct mjs* mjs, mjs_val_t* object) {
+    JsSubghzInst* js_subghz = malloc(sizeof(JsSubghzInst));
+    mjs_val_t subghz_obj = mjs_mk_object(mjs);
+
+    subghz_devices_init();
+
+    mjs_set(mjs, subghz_obj, INST_PROP_NAME, ~0, mjs_mk_foreign(mjs, js_subghz));
+    mjs_set(mjs, subghz_obj, "setup", ~0, MJS_MK_FN(js_subghz_setup));
+    mjs_set(mjs, subghz_obj, "setRx", ~0, MJS_MK_FN(js_subghz_set_rx));
+    mjs_set(mjs, subghz_obj, "setIdle", ~0, MJS_MK_FN(js_subgjz_set_idle));
+    mjs_set(mjs, subghz_obj, "getRssi", ~0, MJS_MK_FN(js_subghz_get_rssi));
+    mjs_set(mjs, subghz_obj, "getState", ~0, MJS_MK_FN(js_subghz_get_state));
+    mjs_set(mjs, subghz_obj, "getFrequency", ~0, MJS_MK_FN(js_subghz_get_frequency));
+    mjs_set(mjs, subghz_obj, "setFrequency", ~0, MJS_MK_FN(js_subghz_set_frequency));
+    mjs_set(mjs, subghz_obj, "isExternal", ~0, MJS_MK_FN(js_subghz_is_external));
+    mjs_set(mjs, subghz_obj, "transmitFile", ~0, MJS_MK_FN(js_subghz_transmit_file));
+
+    *object = subghz_obj;
+
+    return js_subghz;
+}
+
+static void js_subghz_destroy(void* inst) {
+    JsSubghzInst* js_subghz = inst;
+
+    subghz_devices_deinit();
+
+    free(js_subghz);
+}
+
+static const JsModuleDescriptor js_subghz_desc = {
+    "subghz",
+    js_subghz_create,
+    js_subghz_destroy,
+};
+
+static const FlipperAppPluginDescriptor plugin_descriptor = {
+    .appid = PLUGIN_APP_ID,
+    .ep_api_version = PLUGIN_API_VERSION,
+    .entry_point = &js_subghz_desc,
+};
+
+const FlipperAppPluginDescriptor* js_subghz_ep(void) {
+    return &plugin_descriptor;
+}

applications/system/js_app/modules/js_subghz/radio_device_loader.c

@@ -0,0 +1,64 @@
+#include "radio_device_loader.h"
+
+#include <applications/drivers/subghz/cc1101_ext/cc1101_ext_interconnect.h>
+#include <lib/subghz/devices/cc1101_int/cc1101_int_interconnect.h>
+
+static void radio_device_loader_power_on() {
+    uint8_t attempts = 0;
+    while(!furi_hal_power_is_otg_enabled() && attempts++ < 5) {
+        furi_hal_power_enable_otg();
+        //CC1101 power-up time
+        furi_delay_ms(10);
+    }
+}
+
+static void radio_device_loader_power_off() {
+    if(furi_hal_power_is_otg_enabled()) furi_hal_power_disable_otg();
+}
+
+bool radio_device_loader_is_connect_external(const char* name) {
+    bool is_connect = false;
+    bool is_otg_enabled = furi_hal_power_is_otg_enabled();
+
+    if(!is_otg_enabled) {
+        radio_device_loader_power_on();
+    }
+
+    const SubGhzDevice* device = subghz_devices_get_by_name(name);
+    if(device) {
+        is_connect = subghz_devices_is_connect(device);
+    }
+
+    if(!is_otg_enabled) {
+        radio_device_loader_power_off();
+    }
+    return is_connect;
+}
+
+const SubGhzDevice* radio_device_loader_set(
+    const SubGhzDevice* current_radio_device,
+    SubGhzRadioDeviceType radio_device_type) {
+    const SubGhzDevice* radio_device;
+
+    if(radio_device_type == SubGhzRadioDeviceTypeExternalCC1101 &&
+       radio_device_loader_is_connect_external(SUBGHZ_DEVICE_CC1101_EXT_NAME)) {
+        radio_device_loader_power_on();
+        radio_device = subghz_devices_get_by_name(SUBGHZ_DEVICE_CC1101_EXT_NAME);
+        subghz_devices_begin(radio_device);
+    } else if(current_radio_device == NULL) {
+        radio_device = subghz_devices_get_by_name(SUBGHZ_DEVICE_CC1101_INT_NAME);
+    } else {
+        radio_device_loader_end(current_radio_device);
+        radio_device = subghz_devices_get_by_name(SUBGHZ_DEVICE_CC1101_INT_NAME);
+    }
+
+    return radio_device;
+}
+
+void radio_device_loader_end(const SubGhzDevice* radio_device) {
+    furi_assert(radio_device);
+    radio_device_loader_power_off();
+    if(radio_device != subghz_devices_get_by_name(SUBGHZ_DEVICE_CC1101_INT_NAME)) {
+        subghz_devices_end(radio_device);
+    }
+}

applications/system/js_app/modules/js_subghz/radio_device_loader.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <lib/subghz/devices/devices.h>
+
+/** SubGhzRadioDeviceType */
+typedef enum {
+    SubGhzRadioDeviceTypeInternal,
+    SubGhzRadioDeviceTypeExternalCC1101,
+} SubGhzRadioDeviceType;
+
+const SubGhzDevice* radio_device_loader_set(
+    const SubGhzDevice* current_radio_device,
+    SubGhzRadioDeviceType radio_device_type);
+
+void radio_device_loader_end(const SubGhzDevice* radio_device);