From 9b418c9a07db5d6004df054caf59b913bdfa7070 Mon Sep 17 00:00:00 2001 From: Willy-JL <49810075+Willy-JL@users.noreply.github.com> Date: Thu, 16 May 2024 04:51:23 +0100 Subject: [PATCH] SubGHz: Show reason for TX blocked --nobuild --- applications/main/subghz/subghz_i.c | 45 ++++++++++++++++++--------- applications/main/subghz/subghz_i.h | 2 +- targets/f7/api_symbols.csv | 1 + targets/f7/furi_hal/furi_hal_subghz.c | 45 ++++++++++++++++----------- targets/f7/furi_hal/furi_hal_subghz.h | 16 ++++++++++ 5 files changed, 75 insertions(+), 34 deletions(-) diff --git a/applications/main/subghz/subghz_i.c b/applications/main/subghz/subghz_i.c index 757a44007..75e0e49e9 100644 --- a/applications/main/subghz/subghz_i.c +++ b/applications/main/subghz/subghz_i.c @@ -29,7 +29,10 @@ bool subghz_tx_start(SubGhz* subghz, FlipperFormat* flipper_format) { subghz->dialogs, "Error in protocol\nparameters\ndescription"); break; case SubGhzTxRxStartTxStateErrorOnlyRx: - subghz_dialog_message_freq_error(subghz, true); + flipper_format_rewind(flipper_format); + uint32_t temp_data32; + flipper_format_read_uint32(flipper_format, "Frequency", &temp_data32, 1); + subghz_dialog_message_freq_error(subghz, furi_hal_subghz_check_tx(temp_data32)); break; default: @@ -39,19 +42,33 @@ bool subghz_tx_start(SubGhz* subghz, FlipperFormat* flipper_format) { return false; } -void subghz_dialog_message_freq_error(SubGhz* subghz, bool only_rx) { +void subghz_dialog_message_freq_error(SubGhz* subghz, FuriHalSubGhzTx can_tx) { DialogsApp* dialogs = subghz->dialogs; DialogMessage* message = dialog_message_alloc(); - const char* header_text = "Frequency not supported"; - const char* message_text = "Frequency\nis outside of\nsupported range."; + const char* header_text = "Transmission is blocked"; + const char* message_text; - if(only_rx) { - header_text = "Transmission is blocked"; - message_text = "Frequency\nis outside of\ndefault range.\nCheck docs."; + switch(can_tx) { + case FuriHalSubGhzTxAllowed: + default: + return; + case FuriHalSubGhzTxBlockedRegionNotProvisioned: + message_text = "Region is not\nprovisioned.\nUpdate firmware\nor bypass region."; + break; + case FuriHalSubGhzTxBlockedRegion: + message_text = "Frequency outside\nof region range.\nMNTM > Protocols\n> Bypass Region"; + break; + case FuriHalSubGhzTxBlockedDefault: + message_text = "Frequency outside\nof default range.\nMNTM > Protocols\n> Extend Bands"; + break; + case FuriHalSubGhzTxBlockedUnsupported: + header_text = "Frequency not supported"; + message_text = "Frequency is\noutside of\nsupported range."; + break; } dialog_message_set_header(message, header_text, 64, 3, AlignCenter, AlignTop); - dialog_message_set_text(message, message_text, 3, 23, AlignLeft, AlignTop); + dialog_message_set_text(message, message_text, 3, 20, AlignLeft, AlignTop); dialog_message_set_icon(message, &I_WarningDolphinFlip_45x42, 83, 22); @@ -73,6 +90,7 @@ bool subghz_key_load(SubGhz* subghz, const char* file_path, bool show_dialog) { uint32_t temp_data32; float temp_lat = NAN; // NAN or 0.0?? because 0.0 is valid value float temp_lon = NAN; + FuriHalSubGhzTx can_tx = FuriHalSubGhzTxAllowed; do { stream_clean(fff_data_stream); @@ -102,12 +120,14 @@ bool subghz_key_load(SubGhz* subghz, const char* file_path, bool show_dialog) { if(!subghz_txrx_radio_device_is_frequency_valid(subghz->txrx, temp_data32)) { FURI_LOG_E(TAG, "Frequency not supported on chosen radio module"); + can_tx = FuriHalSubGhzTxBlockedUnsupported; load_key_state = SubGhzLoadKeyStateUnsuportedFreq; break; } // TODO: use different frequency allowed lists for differnet modules (non cc1101) - if(!furi_hal_subghz_is_tx_allowed(temp_data32)) { + can_tx = furi_hal_subghz_check_tx(temp_data32); + if(can_tx != FuriHalSubGhzTxAllowed) { FURI_LOG_E(TAG, "This frequency can only be used for RX"); load_key_state = SubGhzLoadKeyStateOnlyRx; @@ -212,14 +232,9 @@ bool subghz_key_load(SubGhz* subghz, const char* file_path, bool show_dialog) { return false; case SubGhzLoadKeyStateUnsuportedFreq: - if(show_dialog) { - subghz_dialog_message_freq_error(subghz, false); - } - return false; - case SubGhzLoadKeyStateOnlyRx: if(show_dialog) { - subghz_dialog_message_freq_error(subghz, true); + subghz_dialog_message_freq_error(subghz, can_tx); } return false; diff --git a/applications/main/subghz/subghz_i.h b/applications/main/subghz/subghz_i.h index 405b4a09d..1343e3a00 100644 --- a/applications/main/subghz/subghz_i.h +++ b/applications/main/subghz/subghz_i.h @@ -115,7 +115,7 @@ void subghz_blink_start(SubGhz* subghz); void subghz_blink_stop(SubGhz* subghz); bool subghz_tx_start(SubGhz* subghz, FlipperFormat* flipper_format); -void subghz_dialog_message_freq_error(SubGhz* subghz, bool only_rx); +void subghz_dialog_message_freq_error(SubGhz* subghz, FuriHalSubGhzTx can_tx); bool subghz_key_load(SubGhz* subghz, const char* file_path, bool show_dialog); bool subghz_get_next_name_file(SubGhz* subghz, uint8_t max_len); diff --git a/targets/f7/api_symbols.csv b/targets/f7/api_symbols.csv index 55b6415e6..ff30664b5 100644 --- a/targets/f7/api_symbols.csv +++ b/targets/f7/api_symbols.csv @@ -1676,6 +1676,7 @@ Function,-,furi_hal_spi_config_init,void, Function,-,furi_hal_spi_config_init_early,void, Function,-,furi_hal_spi_dma_init,void, Function,+,furi_hal_spi_release,void,FuriHalSpiBusHandle* +Function,+,furi_hal_subghz_check_tx,FuriHalSubGhzTx,uint32_t Function,-,furi_hal_subghz_dump_state,void, Function,+,furi_hal_subghz_flush_rx,void, Function,+,furi_hal_subghz_flush_tx,void, diff --git a/targets/f7/furi_hal/furi_hal_subghz.c b/targets/f7/furi_hal/furi_hal_subghz.c index 1350bcd58..d5b7f0cb9 100644 --- a/targets/f7/furi_hal/furi_hal_subghz.c +++ b/targets/f7/furi_hal/furi_hal_subghz.c @@ -1,6 +1,7 @@ #include #include #include +#include #include #include #include @@ -389,32 +390,40 @@ uint32_t furi_hal_subghz_set_frequency_and_path(uint32_t value) { return value; } -bool furi_hal_subghz_is_tx_allowed(uint32_t value) { - if(!furi_hal_subghz.bypass_region) { - if(!_furi_hal_region_is_frequency_allowed(value)) { - FURI_LOG_I(TAG, "Frequency blocked - outside region range"); - return false; - } - - return true; +FuriHalSubGhzTx furi_hal_subghz_check_tx(uint32_t value) { + // Check against extended range of YARD Stick One, no configuration would allow this frequency + if(!furi_hal_subghz_is_frequency_valid(value)) { + FURI_LOG_I(TAG, "Frequency blocked - outside supported range"); + return FuriHalSubGhzTxBlockedUnsupported; } - bool allow_extended_for_int = furi_hal_subghz.extended_frequency_i; - - if(!(allow_extended_for_int) && + // Check against default range, regardless of region restrictions + if(!furi_hal_subghz.extended_frequency_i && !(value >= 299999755 && value <= 350000335) && // was increased from 348 to 350 !(value >= 386999938 && value <= 467750000) && // was increased from 464 to 467.75 !(value >= 778999847 && value <= 928000000)) { FURI_LOG_I(TAG, "Frequency blocked - outside default range"); - return false; - } else if( - (allow_extended_for_int) && // - !furi_hal_subghz_is_frequency_valid(value)) { - FURI_LOG_I(TAG, "Frequency blocked - outside extended range"); - return false; + return FuriHalSubGhzTxBlockedDefault; } - return true; + // Check against region restrictions, tighter than extended and default + if(!furi_hal_subghz.bypass_region) { + if(!furi_hal_region_is_provisioned()) { + FURI_LOG_I(TAG, "Frequency blocked - region not provisioned"); + return FuriHalSubGhzTxBlockedRegionNotProvisioned; + } + if(!_furi_hal_region_is_frequency_allowed(value)) { + FURI_LOG_I(TAG, "Frequency blocked - outside region range"); + return FuriHalSubGhzTxBlockedRegion; + } + } + + // We already checked for extended range, default range, and region range + return FuriHalSubGhzTxAllowed; +} + +bool furi_hal_subghz_is_tx_allowed(uint32_t value) { + return furi_hal_subghz_check_tx(value) == FuriHalSubGhzTxAllowed; } uint32_t furi_hal_subghz_set_frequency(uint32_t value) { diff --git a/targets/f7/furi_hal/furi_hal_subghz.h b/targets/f7/furi_hal/furi_hal_subghz.h index 10d89947a..d41966600 100644 --- a/targets/f7/furi_hal/furi_hal_subghz.h +++ b/targets/f7/furi_hal/furi_hal_subghz.h @@ -165,6 +165,22 @@ bool furi_hal_subghz_is_frequency_valid(uint32_t value); */ uint32_t furi_hal_subghz_set_frequency_and_path(uint32_t value); +typedef enum { + FuriHalSubGhzTxAllowed, // TX is allowed with this configuration + FuriHalSubGhzTxBlockedRegionNotProvisioned, // Region not provisioned and not bypassed + FuriHalSubGhzTxBlockedRegion, // Outside region, needs bypass region + FuriHalSubGhzTxBlockedDefault, // Outisde default, needs extended range + FuriHalSubGhzTxBlockedUnsupported, // No configuration would allow this +} FuriHalSubGhzTx; + +/** Сheck if and why transmission is blocked on this frequency with current config + * + * @param value frequency in Hz + * + * @return tx allowed or blocked enum + */ +FuriHalSubGhzTx furi_hal_subghz_check_tx(uint32_t value); + /** Сheck if transmission is allowed on this frequency with your current config * * @param value frequency in Hz