Mirror/Momentum-Firmware
1
0
Fork 0
mirror of https://github.com/Next-Flip/Momentum-Firmware.git synced 2026-05-17 04:34:44 -07:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'flipperdevices:dev' into dev

Browse Source
This commit is contained in:
Eng1n33r
2022-04-28 21:32:05 +03:00
committed by GitHub
parent 4a1b928229 4526503d81
commit c957f7c72b
34 changed files with 197 additions and 122 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
applications/desktop/helpers/pin_lock.c
View File

@@ -77,6 +77,7 @@ void desktop_pin_lock_init(DesktopSettings* settings) {
furi_hal_rtc_set_flag(FuriHalRtcFlagLock);
furi_hal_usb_disable();
} else {
furi_hal_rtc_set_pin_fails(0);
furi_hal_rtc_reset_flag(FuriHalRtcFlagLock);
furi_hal_usb_enable();
}

12
applications/ibutton/ibutton_app.cpp
View File

@@ -133,18 +133,18 @@ uint8_t iButtonApp::get_file_name_size() {
return file_name_size;
}
void iButtonApp::notify_green_blink() {
notification_message(notification, &sequence_blink_green_10);
void iButtonApp::notify_read() {
notification_message(notification, &sequence_blink_cyan_10);
}
void iButtonApp::notify_emulate() {
notification_message(notification, &sequence_blink_magenta_10);
}
void iButtonApp::notify_yellow_blink() {
notification_message(notification, &sequence_blink_yellow_10);
}
void iButtonApp::notify_red_blink() {
notification_message(notification, &sequence_blink_red_10);
}
void iButtonApp::notify_error() {
notification_message(notification, &sequence_error);
}

4
applications/ibutton/ibutton_app.h
View File

@@ -75,9 +75,9 @@ public:
iButtonWorker* get_key_worker();
iButtonKey* get_key();
void notify_green_blink();
void notify_read();
void notify_yellow_blink();
void notify_red_blink();
void notify_emulate();
void notify_error();
void notify_success();

2
applications/ibutton/scene/ibutton_scene_emulate.cpp
View File

@@ -83,7 +83,7 @@ bool iButtonSceneEmulate::on_event(iButtonApp* app, iButtonEvent* event) {
app->notify_yellow_blink();
consumed = true;
} else if(event->type == iButtonEvent::Type::EventTypeTick) {
app->notify_red_blink();
app->notify_emulate();
consumed = true;
}

2
applications/ibutton/scene/ibutton_scene_read.cpp
View File

@@ -54,7 +54,7 @@ bool iButtonSceneRead::on_event(iButtonApp* app, iButtonEvent* event) {
}
} else if(event->type == iButtonEvent::Type::EventTypeTick) {
consumed = true;
app->notify_red_blink();
app->notify_read();
}
return consumed;

2
applications/ibutton/scene/ibutton_scene_write.cpp
View File

@@ -95,7 +95,7 @@ bool iButtonSceneWrite::on_event(iButtonApp* app, iButtonEvent* event) {
if(blink_yellow) {
app->notify_yellow_blink();
} else {
app->notify_red_blink();
app->notify_emulate();
}
}

44
applications/infrared/infrared_app.cpp
View File

@@ -211,46 +211,12 @@ void InfraredApp::notify_success() {
notification_message(notification, &sequence_success);
}
void InfraredApp::notify_red_blink() {
notification_message(notification, &sequence_blink_red_10);
void InfraredApp::notify_blink_read() {
notification_message(notification, &sequence_blink_cyan_10);
}
void InfraredApp::notify_click() {
static const NotificationSequence sequence = {
&message_click,
&message_delay_1,
&message_sound_off,
NULL,
};
notification_message_block(notification, &sequence);
}
void InfraredApp::notify_click_and_green_blink() {
static const NotificationSequence sequence = {
&message_click,
&message_delay_1,
&message_sound_off,
&message_green_255,
&message_delay_10,
&message_green_0,
&message_do_not_reset,
NULL,
};
notification_message_block(notification, &sequence);
}
void InfraredApp::notify_blink_green() {
static const NotificationSequence sequence = {
&message_green_255,
&message_delay_10,
&message_green_0,
&message_do_not_reset,
NULL,
};
notification_message(notification, &sequence);
void InfraredApp::notify_blink_send() {
notification_message(notification, &sequence_blink_magenta_10);
}
DialogsApp* InfraredApp::get_dialogs() {
@@ -279,5 +245,5 @@ void InfraredApp::set_received_signal(const InfraredAppSignal& signal) {
void InfraredApp::signal_sent_callback(void* context) {
InfraredApp* app = static_cast<InfraredApp*>(context);
app->notify_blink_green();
app->notify_blink_send();
}

10
applications/infrared/infrared_app.h
View File

@@ -217,17 +217,13 @@ public:
/** Play success notification */
void notify_success();
/** Play red blink notification */
void notify_red_blink();
void notify_blink_read();
/** Light green */
void notify_green_on();
/** Disable green light */
void notify_green_off();
/** Play click sound */
void notify_click();
/** Play click and green notification */
void notify_click_and_green_blink();
/** Blink green light */
void notify_blink_green();
/** Blink on send */
void notify_blink_send();
/** Get Dialogs instance */
DialogsApp* get_dialogs();

2
applications/infrared/scene/infrared_app_scene_learn.cpp
View File

@@ -51,7 +51,7 @@ bool InfraredAppSceneLearn::on_event(InfraredApp* app, InfraredAppEvent* event)
switch(event->type) {
case InfraredAppEvent::Type::Tick:
consumed = true;
app->notify_red_blink();
app->notify_blink_read();
break;
case InfraredAppEvent::Type::InfraredMessageReceived:
app->notify_success();

1
applications/infrared/scene/infrared_app_scene_learn_success.cpp
View File

@@ -95,7 +95,6 @@ bool InfraredAppSceneLearnSuccess::on_event(InfraredApp* app, InfraredAppEvent*
case DialogExPressCenter:
if(!button_pressed) {
button_pressed = true;
app->notify_click_and_green_blink();
auto signal = app->get_received_signal();
if(signal.is_raw()) {

3
applications/infrared/scene/infrared_app_scene_remote.cpp
View File

@@ -72,14 +72,12 @@ bool InfraredAppSceneRemote::on_event(InfraredApp* app, InfraredAppEvent* event)
switch(event->payload.menu_index) {
case ButtonIndexPlus:
furi_assert(event->type == InfraredAppEvent::Type::MenuSelected);
app->notify_click();
buttonmenu_item_selected = event->payload.menu_index;
app->set_learn_new_remote(false);
app->switch_to_next_scene(InfraredApp::Scene::Learn);
break;
case ButtonIndexEdit:
furi_assert(event->type == InfraredAppEvent::Type::MenuSelected);
app->notify_click();
buttonmenu_item_selected = event->payload.menu_index;
app->switch_to_next_scene(InfraredApp::Scene::Edit);
break;
@@ -89,7 +87,6 @@ bool InfraredAppSceneRemote::on_event(InfraredApp* app, InfraredAppEvent* event)
if(pressed && !button_pressed) {
button_pressed = true;
app->notify_click_and_green_blink();
auto button_signal =
app->get_remote_manager()->get_button_data(event->payload.menu_index);

2
applications/infrared/scene/infrared_app_scene_universal_common.cpp
View File

@@ -56,6 +56,7 @@ bool InfraredAppSceneUniversalCommon::on_event(InfraredApp* app, InfraredAppEven
if(brute_force_started) {
if(event->type == InfraredAppEvent::Type::Tick) {
auto view_manager = app->get_view_manager();
app->notify_blink_send();
InfraredAppEvent tick_event = {.type = InfraredAppEvent::Type::Tick};
view_manager->send_event(&tick_event);
bool result = brute_force.send_next_bruteforce();
@@ -81,6 +82,7 @@ bool InfraredAppSceneUniversalCommon::on_event(InfraredApp* app, InfraredAppEven
DOLPHIN_DEED(DolphinDeedIrBruteForce);
brute_force_started = true;
show_popup(app, record_amount);
app->notify_blink_send();
} else {
app->switch_to_previous_scene();
}

2
applications/lfrfid/scene/lfrfid_app_scene_emulate.cpp
View File

@@ -29,7 +29,7 @@ bool LfRfidAppSceneEmulate::on_event(LfRfidApp* app, LfRfidApp::Event* event) {
bool consumed = false;
if(event->type == LfRfidApp::EventType::Tick) {
notification_message(app->notification, &sequence_blink_cyan_10);
notification_message(app->notification, &sequence_blink_magenta_10);
}
return consumed;

4
applications/lfrfid/scene/lfrfid_app_scene_read.cpp
View File

@@ -24,9 +24,9 @@ bool LfRfidAppSceneRead::on_event(LfRfidApp* app, LfRfidApp::Event* event) {
if(app->worker.any_read()) {
notification_message(app->notification, &sequence_blink_green_10);
} else if(app->worker.detect()) {
notification_message(app->notification, &sequence_blink_blue_10);
notification_message(app->notification, &sequence_blink_cyan_10);
} else {
notification_message(app->notification, &sequence_blink_red_10);
notification_message(app->notification, &sequence_blink_cyan_10);
}
}
}

4
applications/lfrfid/scene/lfrfid_app_scene_write.cpp
View File

@@ -32,7 +32,7 @@ bool LfRfidAppSceneWrite::on_event(LfRfidApp* app, LfRfidApp::Event* event) {
switch(result) {
case RfidWorker::WriteResult::Nothing:
notification_message(app->notification, &sequence_blink_yellow_10);
notification_message(app->notification, &sequence_blink_magenta_10);
break;
case RfidWorker::WriteResult::Ok:
notification_message(app->notification, &sequence_success);
@@ -51,7 +51,7 @@ bool LfRfidAppSceneWrite::on_event(LfRfidApp* app, LfRfidApp::Event* event) {
AlignTop);
card_not_supported = true;
}
notification_message(app->notification, &sequence_blink_red_10);
notification_message(app->notification, &sequence_blink_yellow_10);
break;
}
}

7
applications/notification/notification_messages.c
View File

@@ -309,6 +309,13 @@ const NotificationSequence sequence_blink_cyan_10 = {
NULL,
};
const NotificationSequence sequence_blink_magenta_10 = {
&message_red_255,
&message_blue_255,
&message_delay_10,
NULL,
};
const NotificationSequence sequence_blink_red_100 = {
&message_red_255,
&message_delay_100,

1
applications/notification/notification_messages.h
View File

@@ -100,6 +100,7 @@ extern const NotificationSequence sequence_blink_red_10;
extern const NotificationSequence sequence_blink_green_10;
extern const NotificationSequence sequence_blink_yellow_10;
extern const NotificationSequence sequence_blink_cyan_10;
extern const NotificationSequence sequence_blink_magenta_10;
extern const NotificationSequence sequence_blink_red_100;
extern const NotificationSequence sequence_blink_green_100;

3
applications/subghz/helpers/subghz_custom_event.h
View File

@@ -19,6 +19,8 @@ typedef enum {
SubGhzCustomEventSceneShowErrorOk,
SubGhzCustomEventSceneShowErrorSub,
SubGhzCustomEventSceneShowOnlyRX,
SubGhzCustomEventSceneAnalyzerLock,
SubGhzCustomEventSceneAnalyzerUnlock,
SubGhzCustomEventSceneExit,
SubGhzCustomEventSceneStay,
@@ -35,7 +37,6 @@ typedef enum {
SubGhzCustomEventViewReadRAWSendStart,
SubGhzCustomEventViewReadRAWSendStop,
SubGhzCustomEventViewReadRAWSave,
SubGhzCustomEventViewReadRAWVibro,
SubGhzCustomEventViewReadRAWTXRXStop,
SubGhzCustomEventViewReadRAWMore,

14
applications/subghz/scenes/subghz_scene_frequency_analyzer.c
View File

@@ -17,10 +17,20 @@ void subghz_scene_frequency_analyzer_on_enter(void* context) {
}
bool subghz_scene_frequency_analyzer_on_event(void* context, SceneManagerEvent event) {
//SubGhz* subghz = context;
SubGhz* subghz = context;
if(event.type == SceneManagerEventTypeCustom) {
if(event.event == SubGhzCustomEventSceneAnalyzerLock) {
notification_message(subghz->notifications, &sequence_set_green_255);
return true;
} else if(event.event == SubGhzCustomEventSceneAnalyzerUnlock) {
notification_message(subghz->notifications, &sequence_reset_rgb);
return true;
}
}
return false;
}
void subghz_scene_frequency_analyzer_on_exit(void* context) {
// SubGhz* subghz = context;
SubGhz* subghz = context;
notification_message(subghz->notifications, &sequence_reset_rgb);
}

29
applications/subghz/scenes/subghz_scene_read_raw.c
View File

@@ -168,11 +168,7 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
case SubGhzCustomEventViewReadRAWErase:
subghz->txrx->rx_key_state = SubGhzRxKeyStateIDLE;
return true;
break;
case SubGhzCustomEventViewReadRAWVibro:
notification_message(subghz->notifications, &sequence_single_vibro);
notification_message(subghz->notifications, &sequence_reset_rgb);
return true;
break;
@@ -209,7 +205,7 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
(SubGhzProtocolEncoderRAW*)subghz->txrx->transmitter->protocol_instance,
subghz_scene_read_raw_callback_end_tx,
subghz);
subghz->state_notifications = SubGhzNotificationStateTX;
subghz->state_notifications = SubGhzNotificationStateTx;
}
}
}
@@ -231,6 +227,10 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
subghz_rx_end(subghz);
subghz_sleep(subghz);
};
size_t spl_count = subghz_protocol_raw_get_sample_write(
(SubGhzProtocolDecoderRAW*)subghz->txrx->decoder_result);
subghz_protocol_raw_save_to_file_stop(
(SubGhzProtocolDecoderRAW*)subghz->txrx->decoder_result);
@@ -241,6 +241,12 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
subghz_protocol_raw_gen_fff_data(subghz->txrx->fff_data, string_get_cstr(temp_str));
string_clear(temp_str);
if(spl_count > 0) {
notification_message(subghz->notifications, &sequence_set_green_255);
} else {
notification_message(subghz->notifications, &sequence_reset_rgb);
}
subghz->state_notifications = SubGhzNotificationStateIDLE;
subghz->txrx->rx_key_state = SubGhzRxKeyStateAddKey;
@@ -263,7 +269,7 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
subghz_begin(subghz, subghz->txrx->preset);
subghz_rx(subghz, subghz->txrx->frequency);
}
subghz->state_notifications = SubGhzNotificationStateRX;
subghz->state_notifications = SubGhzNotificationStateRx;
subghz->txrx->rx_key_state = SubGhzRxKeyStateAddKey;
} else {
string_set(subghz->error_str, "Function requires\nan SD card.");
@@ -288,16 +294,16 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
}
} else if(event.type == SceneManagerEventTypeTick) {
switch(subghz->state_notifications) {
case SubGhzNotificationStateRX:
notification_message(subghz->notifications, &sequence_blink_blue_10);
case SubGhzNotificationStateRx:
notification_message(subghz->notifications, &sequence_blink_cyan_10);
subghz_read_raw_update_sample_write(
subghz->subghz_read_raw,
subghz_protocol_raw_get_sample_write(
(SubGhzProtocolDecoderRAW*)subghz->txrx->decoder_result));
subghz_read_raw_add_data_rssi(subghz->subghz_read_raw, furi_hal_subghz_get_rssi());
break;
case SubGhzNotificationStateTX:
notification_message(subghz->notifications, &sequence_blink_green_10);
case SubGhzNotificationStateTx:
notification_message(subghz->notifications, &sequence_blink_magenta_10);
subghz_read_raw_update_sin(subghz->subghz_read_raw);
break;
default:
@@ -316,6 +322,7 @@ void subghz_scene_read_raw_on_exit(void* context) {
subghz_sleep(subghz);
};
subghz->state_notifications = SubGhzNotificationStateIDLE;
notification_message(subghz->notifications, &sequence_reset_rgb);
//filter restoration
subghz_receiver_set_filter(subghz->txrx->receiver, SubGhzProtocolFlag_Decodable);

25
applications/subghz/scenes/subghz_scene_receiver.c
View File

@@ -1,6 +1,19 @@
#include "../subghz_i.h"
#include "../views/receiver.h"
static const NotificationSequence subghs_sequence_rx = {
&message_green_255,
&message_vibro_on,
&message_note_c6,
&message_delay_50,
&message_sound_off,
&message_vibro_off,
&message_delay_50,
NULL,
};
static void subghz_scene_receiver_update_statusbar(void* context) {
SubGhz* subghz = context;
string_t history_stat_str;
@@ -50,6 +63,8 @@ static void subghz_scene_add_to_history_callback(
subghz_receiver_reset(receiver);
string_reset(str_buff);
subghz->state_notifications = SubGhzNotificationStateRxDone;
subghz_history_get_text_item_menu(
subghz->txrx->history, str_buff, subghz_history_get_item(subghz->txrx->history) - 1);
subghz_view_receiver_add_item_to_menu(
@@ -95,7 +110,7 @@ void subghz_scene_receiver_on_enter(void* context) {
subghz_receiver_set_rx_callback(
subghz->txrx->receiver, subghz_scene_add_to_history_callback, subghz);
subghz->state_notifications = SubGhzNotificationStateRX;
subghz->state_notifications = SubGhzNotificationStateRx;
if(subghz->txrx->txrx_state == SubGhzTxRxStateRx) {
subghz_rx_end(subghz);
};
@@ -161,8 +176,12 @@ bool subghz_scene_receiver_on_event(void* context, SceneManagerEvent event) {
}
switch(subghz->state_notifications) {
case SubGhzNotificationStateRX:
notification_message(subghz->notifications, &sequence_blink_blue_10);
case SubGhzNotificationStateRx:
notification_message(subghz->notifications, &sequence_blink_cyan_10);
break;
case SubGhzNotificationStateRxDone:
notification_message(subghz->notifications, &subghs_sequence_rx);
subghz->state_notifications = SubGhzNotificationStateRx;
break;
default:
break;

16
applications/subghz/scenes/subghz_scene_receiver_info.c
View File

@@ -125,7 +125,7 @@ bool subghz_scene_receiver_info_on_event(void* context, SceneManagerEvent event)
subghz->txrx->history, subghz->txrx->idx_menu_chosen))) {
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowOnlyRx);
} else {
subghz->state_notifications = SubGhzNotificationStateTX;
subghz->state_notifications = SubGhzNotificationStateTx;
}
}
return true;
@@ -142,7 +142,7 @@ bool subghz_scene_receiver_info_on_event(void* context, SceneManagerEvent event)
if(subghz->txrx->hopper_state == SubGhzHopperStatePause) {
subghz->txrx->hopper_state = SubGhzHopperStateRunnig;
}
subghz->state_notifications = SubGhzNotificationStateRX;
subghz->state_notifications = SubGhzNotificationStateRx;
return true;
} else if(event.event == SubGhzCustomEventSceneReceiverInfoSave) {
//CC1101 Stop RX -> Save
@@ -169,11 +169,15 @@ bool subghz_scene_receiver_info_on_event(void* context, SceneManagerEvent event)
subghz_hopper_update(subghz);
}
switch(subghz->state_notifications) {
case SubGhzNotificationStateTX:
notification_message(subghz->notifications, &sequence_blink_red_10);
case SubGhzNotificationStateTx:
notification_message(subghz->notifications, &sequence_blink_magenta_10);
break;
case SubGhzNotificationStateRX:
notification_message(subghz->notifications, &sequence_blink_blue_10);
case SubGhzNotificationStateRx:
notification_message(subghz->notifications, &sequence_blink_cyan_10);
break;
case SubGhzNotificationStateRxDone:
notification_message(subghz->notifications, &sequence_blink_green_100);
subghz->state_notifications = SubGhzNotificationStateRx;
break;
default:
break;

10
applications/subghz/scenes/subghz_scene_show_error.c
View File

@@ -1,6 +1,13 @@
#include "../subghz_i.h"
#include "../helpers/subghz_custom_event.h"
static const NotificationSequence subghs_sequence_sd_error = {
&message_red_255,
&message_green_255,
&message_do_not_reset,
NULL,
};
void subghz_scene_show_error_callback(GuiButtonType result, InputType type, void* context) {
furi_assert(context);
SubGhz* subghz = context;
@@ -31,6 +38,8 @@ void subghz_scene_show_error_on_enter(void* context) {
SubGhzCustomEventManagerSet) {
widget_add_button_element(
subghz->widget, GuiButtonTypeRight, "Ok", subghz_scene_show_error_callback, subghz);
} else {
notification_message(subghz->notifications, &subghs_sequence_sd_error);
}
widget_add_button_element(
@@ -81,4 +90,5 @@ void subghz_scene_show_error_on_exit(void* context) {
subghz->scene_manager, SubGhzSceneShowError, SubGhzCustomEventManagerNoSet);
widget_reset(subghz->widget);
string_reset(subghz->error_str);
notification_message(subghz->notifications, &sequence_reset_rgb);
}

4
applications/subghz/scenes/subghz_scene_show_error_sub.c
View File

@@ -18,6 +18,8 @@ void subghz_scene_show_error_sub_on_enter(void* context) {
popup_set_callback(popup, subghz_scene_show_error_sub_popup_callback);
popup_enable_timeout(popup);
view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdPopup);
notification_message(subghz->notifications, &sequence_set_red_255);
}
bool subghz_scene_show_error_sub_on_event(void* context, SceneManagerEvent event) {
@@ -45,4 +47,6 @@ void subghz_scene_show_error_sub_on_exit(void* context) {
popup_set_timeout(popup, 0);
popup_disable_timeout(popup);
string_reset(subghz->error_str);
notification_message(subghz->notifications, &sequence_reset_rgb);
}

6
applications/subghz/scenes/subghz_scene_transmitter.c
View File

@@ -76,7 +76,7 @@ bool subghz_scene_transmitter_on_event(void* context, SceneManagerEvent event) {
if(!subghz_tx_start(subghz, subghz->txrx->fff_data)) {
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowOnlyRx);
} else {
subghz->state_notifications = SubGhzNotificationStateTX;
subghz->state_notifications = SubGhzNotificationStateTx;
subghz_scene_transmitter_update_data_show(subghz);
}
}
@@ -98,8 +98,8 @@ bool subghz_scene_transmitter_on_event(void* context, SceneManagerEvent event) {
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowErrorSub);
}
} else if(event.type == SceneManagerEventTypeTick) {
if(subghz->state_notifications == SubGhzNotificationStateTX) {
notification_message(subghz->notifications, &sequence_blink_red_10);
if(subghz->state_notifications == SubGhzNotificationStateTx) {
notification_message(subghz->notifications, &sequence_blink_magenta_10);
}
return true;
}

5
applications/subghz/subghz_i.h
View File

@@ -42,8 +42,9 @@
typedef enum {
SubGhzNotificationStateStarting,
SubGhzNotificationStateIDLE,
SubGhzNotificationStateTX,
SubGhzNotificationStateRX,
SubGhzNotificationStateTx,
SubGhzNotificationStateRx,
SubGhzNotificationStateRxDone,
} SubGhzNotificationState;
/** SubGhzTxRx state */

12
applications/subghz/views/subghz_frequency_analyzer.c
View File

@@ -19,6 +19,7 @@ struct SubGhzFrequencyAnalyzer {
SubGhzFrequencyAnalyzerWorker* worker;
SubGhzFrequencyAnalyzerCallback callback;
void* context;
bool locked;
};
typedef struct {
@@ -86,6 +87,17 @@ bool subghz_frequency_analyzer_input(InputEvent* event, void* context) {
void subghz_frequency_analyzer_pair_callback(void* context, uint32_t frequency, float rssi) {
SubGhzFrequencyAnalyzer* instance = context;
if((rssi == 0.f) && (instance->locked)) {
if(instance->callback) {
instance->callback(SubGhzCustomEventSceneAnalyzerUnlock, instance->context);
}
} else if((rssi != 0.f) && (!instance->locked)) {
if(instance->callback) {
instance->callback(SubGhzCustomEventSceneAnalyzerLock, instance->context);
}
}
instance->locked = (rssi != 0.f);
with_view_model(
instance->view, (SubGhzFrequencyAnalyzerModel * model) {
model->rssi = rssi;

2
applications/subghz/views/subghz_read_raw.c
View File

@@ -293,7 +293,6 @@ bool subghz_read_raw_input(InputEvent* event, void* context) {
case SubGhzReadRAWStatusIDLE:
// Start TX
instance->callback(SubGhzCustomEventViewReadRAWSendStart, instance->context);
instance->callback(SubGhzCustomEventViewReadRAWVibro, instance->context);
model->satus = SubGhzReadRAWStatusTXRepeat;
ret = true;
break;
@@ -304,7 +303,6 @@ bool subghz_read_raw_input(InputEvent* event, void* context) {
case SubGhzReadRAWStatusLoadKeyIDLE:
// Start Load Key TX
instance->callback(SubGhzCustomEventViewReadRAWSendStart, instance->context);
instance->callback(SubGhzCustomEventViewReadRAWVibro, instance->context);
model->satus = SubGhzReadRAWStatusLoadKeyTXRepeat;
ret = true;
break;

8
applications/u2f/scenes/u2f_scene_main.c
View File

@@ -62,15 +62,17 @@ bool u2f_scene_main_on_event(void* context, SceneManagerEvent event) {
notification_message(app->notifications, &sequence_display_on);
notification_message(app->notifications, &sequence_single_vibro);
}
notification_message(app->notifications, &sequence_blink_blue_10);
notification_message(app->notifications, &sequence_blink_magenta_10);
} else if(event.event == U2fCustomEventWink) {
notification_message(app->notifications, &sequence_blink_green_10);
notification_message(app->notifications, &sequence_blink_magenta_10);
} else if(event.event == U2fCustomEventAuthSuccess) {
notification_message_block(app->notifications, &sequence_set_green_255);
DOLPHIN_DEED(DolphinDeedU2fAuthorized);
osTimerStart(app->timer, U2F_SUCCESS_TIMEOUT);
app->event_cur = U2fCustomEventNone;
u2f_view_set_state(app->u2f_view, U2fMsgSuccess);
} else if(event.event == U2fCustomEventTimeout) {
notification_message_block(app->notifications, &sequence_reset_rgb);
app->event_cur = U2fCustomEventNone;
u2f_view_set_state(app->u2f_view, U2fMsgIdle);
} else if(event.event == U2fCustomEventConfirm) {
@@ -78,6 +80,7 @@ bool u2f_scene_main_on_event(void* context, SceneManagerEvent event) {
u2f_confirm_user_present(app->u2f_instance);
}
} else if(event.event == U2fCustomEventDataError) {
notification_message(app->notifications, &sequence_set_red_255);
osTimerStop(app->timer);
u2f_view_set_state(app->u2f_view, U2fMsgError);
}
@@ -108,6 +111,7 @@ void u2f_scene_main_on_enter(void* context) {
void u2f_scene_main_on_exit(void* context) {
U2fApp* app = context;
notification_message_block(app->notifications, &sequence_reset_rgb);
osTimerStop(app->timer);
osTimerDelete(app->timer);
if(app->u2f_ready == true) {

15
applications/updater/util/update_task_worker_backup.c
View File

@@ -29,7 +29,8 @@ static bool update_task_pre_update(UpdateTask* update_task) {
update_task->state.total_stages = 1;
update_task_set_progress(update_task, UpdateTaskStageLfsBackup, 0);
furi_hal_rtc_set_boot_mode(FuriHalRtcBootModeNormal); // to avoid bootloops
/* to avoid bootloops */
furi_hal_rtc_set_boot_mode(FuriHalRtcBootModeNormal);
if((success = lfs_backup_create(update_task->storage, string_get_cstr(backup_file_path)))) {
furi_hal_rtc_set_boot_mode(FuriHalRtcBootModeUpdate);
}
@@ -61,7 +62,7 @@ static bool update_task_post_update(UpdateTask* update_task) {
string_t file_path;
string_init(file_path);
// status text is too long, too few stages to bother with a counter
/* status text is too long, too few stages to bother with a counter */
update_task->state.total_stages = 0;
do {
@@ -70,9 +71,6 @@ static bool update_task_post_update(UpdateTask* update_task) {
string_get_cstr(update_task->update_path), LFS_BACKUP_DEFAULT_FILENAME, file_path);
bool unpack_resources = !string_empty_p(update_task->manifest->resource_bundle);
if(unpack_resources) {
update_task->state.total_stages++;
}
update_task_set_progress(update_task, UpdateTaskStageLfsRestore, 0);
furi_hal_rtc_set_boot_mode(FuriHalRtcBootModeNormal);
@@ -117,7 +115,7 @@ int32_t update_task_worker_backup_restore(void* context) {
FuriHalRtcBootMode boot_mode = furi_hal_rtc_get_boot_mode();
if((boot_mode != FuriHalRtcBootModePreUpdate) && (boot_mode != FuriHalRtcBootModePostUpdate)) {
// no idea how we got here. Clear to normal boot
/* no idea how we got here. Clear to normal boot */
furi_hal_rtc_set_boot_mode(FuriHalRtcBootModeNormal);
return UPDATE_TASK_NOERR;
}
@@ -128,12 +126,17 @@ int32_t update_task_worker_backup_restore(void* context) {
return UPDATE_TASK_FAILED;
}
/* Waiting for BT service to 'start', so we don't race for boot mode */
furi_record_open("bt");
if(boot_mode == FuriHalRtcBootModePreUpdate) {
success = update_task_pre_update(update_task);
} else if(boot_mode == FuriHalRtcBootModePostUpdate) {
success = update_task_post_update(update_task);
}
furi_record_close("bt");
if(success) {
update_task_set_progress(update_task, UpdateTaskStageCompleted, 100);
} else {

14
lib/nfc_protocols/emv.c
View File

@@ -58,6 +58,16 @@ static const uint8_t pdol_ans[] = {0x77, 0x40, 0x82, 0x02, 0x20, 0x00, 0x57, 0x1
0xC9, 0x85, 0x9F, 0x27, 0x01, 0x00, 0x9F, 0x36, 0x02, 0x06,
0x0C, 0x9F, 0x6C, 0x02, 0x10, 0x00, 0x90, 0x00};
static void emv_trace(FuriHalNfcTxRxContext* tx_rx, const char* message) {
if(furi_log_get_level() == FuriLogLevelTrace) {
FURI_LOG_T(TAG, "%s", message);
for(size_t i = 0; i < tx_rx->rx_bits / 8; i++) {
printf("%02X ", tx_rx->rx_data[i]);
}
printf("\r\n");
}
}
static uint16_t emv_parse_TLV(uint8_t* dest, uint8_t* src, uint16_t* idx) {
uint8_t len = src[*idx + 1];
memcpy(dest, &src[*idx + 2], len);
@@ -113,6 +123,7 @@ bool emv_select_ppse(FuriHalNfcTxRxContext* tx_rx, EmvApplication* app) {
FURI_LOG_D(TAG, "Send select PPSE");
if(furi_hal_nfc_tx_rx(tx_rx, 300)) {
emv_trace(tx_rx, "Select PPSE answer:");
if(emv_decode_ppse_response(tx_rx->rx_data, tx_rx->rx_bits / 8, app)) {
app_aid_found = true;
} else {
@@ -169,6 +180,7 @@ bool emv_select_app(FuriHalNfcTxRxContext* tx_rx, EmvApplication* app) {
FURI_LOG_D(TAG, "Start application");
if(furi_hal_nfc_tx_rx(tx_rx, 300)) {
emv_trace(tx_rx, "Start application answer:");
if(emv_decode_select_app_response(tx_rx->rx_data, tx_rx->rx_bits / 8, app)) {
select_app_success = true;
} else {
@@ -251,6 +263,7 @@ static bool emv_get_processing_options(FuriHalNfcTxRxContext* tx_rx, EmvApplicat
FURI_LOG_D(TAG, "Get proccessing options");
if(furi_hal_nfc_tx_rx(tx_rx, 300)) {
emv_trace(tx_rx, "Get processing options answer:");
if(emv_decode_get_proc_opt(tx_rx->rx_data, tx_rx->rx_bits / 8, app)) {
card_num_read = true;
}
@@ -306,6 +319,7 @@ static bool emv_read_sfi_record(
tx_rx->tx_rx_type = FuriHalNfcTxRxTypeDefault;
if(furi_hal_nfc_tx_rx(tx_rx, 300)) {
emv_trace(tx_rx, "SFI record:");
if(emv_decode_read_sfi_record(tx_rx->rx_data, tx_rx->rx_bits / 8, app)) {
card_num_read = true;
}

29
lib/nfc_protocols/mifare_ultralight.c
View File

@@ -14,6 +14,8 @@ static void mf_ul_set_default_version(MfUltralightReader* reader, MfUltralightDa
data->type = MfUltralightTypeUnknown;
reader->pages_to_read = 16;
reader->support_fast_read = false;
reader->support_tearing_flags = false;
reader->support_counters = false;
}
bool mf_ultralight_read_version(
@@ -40,22 +42,32 @@ bool mf_ultralight_read_version(
data->type = MfUltralightTypeUL11;
reader->pages_to_read = 20;
reader->support_fast_read = true;
reader->support_tearing_flags = true;
reader->support_counters = true;
} else if(version->storage_size == 0x0E) {
data->type = MfUltralightTypeUL21;
reader->pages_to_read = 41;
reader->support_fast_read = true;
reader->support_tearing_flags = true;
reader->support_counters = true;
} else if(version->storage_size == 0x0F) {
data->type = MfUltralightTypeNTAG213;
reader->pages_to_read = 45;
reader->support_fast_read = false;
reader->support_fast_read = true;
reader->support_tearing_flags = false;
reader->support_counters = false;
} else if(version->storage_size == 0x11) {
data->type = MfUltralightTypeNTAG215;
reader->pages_to_read = 135;
reader->support_fast_read = false;
reader->support_fast_read = true;
reader->support_tearing_flags = false;
reader->support_counters = false;
} else if(version->storage_size == 0x13) {
data->type = MfUltralightTypeNTAG216;
reader->pages_to_read = 231;
reader->support_fast_read = false;
reader->support_fast_read = true;
reader->support_tearing_flags = false;
reader->support_counters = false;
} else {
mf_ul_set_default_version(reader, data);
break;
@@ -190,9 +202,10 @@ bool mf_ul_read_card(
// Read Signature
mf_ultralight_read_signature(tx_rx, data);
}
// Read data blocks
if(reader->support_fast_read) {
if(reader->support_counters) {
mf_ultralight_read_counters(tx_rx, data);
}
if(reader->support_tearing_flags) {
mf_ultralight_read_tearing_flags(tx_rx, data);
}
card_read = mf_ultralight_read_pages(tx_rx, reader, data);
@@ -230,11 +243,11 @@ void mf_ul_prepare_emulation(MfUltralightEmulator* emulator, MfUltralightData* d
} else if(data->type == MfUltralightTypeUL21) {
emulator->support_fast_read = true;
} else if(data->type == MfUltralightTypeNTAG213) {
emulator->support_fast_read = false;
emulator->support_fast_read = true;
} else if(data->type == MfUltralightTypeNTAG215) {
emulator->support_fast_read = false;
emulator->support_fast_read = true;
} else if(data->type == MfUltralightTypeNTAG216) {
emulator->support_fast_read = false;
emulator->support_fast_read = true;
}
if(data->type >= MfUltralightTypeNTAG213) {

2
lib/nfc_protocols/mifare_ultralight.h
View File

@@ -74,6 +74,8 @@ typedef struct {
uint8_t pages_to_read;
uint8_t pages_read;
bool support_fast_read;
bool support_tearing_flags;
bool support_counters;
} MfUltralightReader;
typedef struct {

18
lib/toolbox/tar/tar_archive.c
View File

@@ -206,12 +206,14 @@ static int archive_extract_foreach_cb(mtar_t* tar, const mtar_header_t* header,
bool failed = false;
uint8_t n_tries = FILE_OPEN_NTRIES;
do {
while(
(n_tries-- > 0) &&
!storage_file_open(out_file, string_get_cstr(fname), FSAM_WRITE, FSOM_CREATE_ALWAYS)) {
while(n_tries-- > 0) {
if(storage_file_open(
out_file, string_get_cstr(fname), FSAM_WRITE, FSOM_CREATE_ALWAYS)) {
break;
}
FURI_LOG_W(TAG, "Failed to open '%s', reties: %d", string_get_cstr(fname), n_tries);
storage_file_close(out_file);
osDelay(FILE_OPEN_RETRY_DELAY);
continue;
}
if(!storage_file_is_open(out_file)) {
@@ -257,11 +259,13 @@ bool tar_archive_add_file(
File* src_file = storage_file_alloc(archive->storage);
uint8_t n_tries = FILE_OPEN_NTRIES;
do {
while((n_tries-- > 0) &&
!storage_file_open(src_file, fs_file_path, FSAM_READ, FSOM_OPEN_EXISTING)) {
while(n_tries-- > 0) {
if(storage_file_open(src_file, fs_file_path, FSAM_READ, FSOM_OPEN_EXISTING)) {
break;
}
FURI_LOG_W(TAG, "Failed to open '%s', reties: %d", fs_file_path, n_tries);
storage_file_close(src_file);
osDelay(FILE_OPEN_RETRY_DELAY);
continue;
}
if(!storage_file_is_open(src_file) ||