Mirrors/unleashed-firmware
2
0
Fork 0
mirror of https://github.com/DarkFlippers/unleashed-firmware synced 2024-11-22 12:33:11 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge branch 'fz-dev' into dev

Browse source
This commit is contained in:
Eng1n33r 2022-07-04 21:57:40 +03:00
commit 41341658dd
No known key found for this signature in database
GPG key ID: 6C4C311DFD4B4AB5
62 changed files with 1405 additions and 221 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

109
SConstruct
View file

@ -28,15 +28,41 @@ SConscript("site_scons/cc.scons", exports={"ENV": coreenv})
# Store root dir in environment for certain tools
coreenv["ROOT_DIR"] = Dir(".")
# Create a separate "dist" environment and add construction envs to it
distenv = coreenv.Clone(
tools=["fbt_dist", "openocd"],
GDBOPTS="-ex 'target extended-remote | ${OPENOCD} -c \"gdb_port pipe\" ${OPENOCD_OPTS}' "
'-ex "set confirm off" ',
tools=["fbt_dist", "openocd", "blackmagic"],
OPENOCD_GDB_PIPE=["|openocd -c 'gdb_port pipe' ${[SINGLEQUOTEFUNC(OPENOCD_OPTS)]}"],
GDBOPTS_BASE=[
"-ex",
"target extended-remote ${GDBREMOTE}",
"-ex",
"set confirm off",
],
GDBOPTS_BLACKMAGIC=[
"-ex",
"monitor swdp_scan",
"-ex",
"monitor debug_bmp enable",
"-ex",
"attach 1",
"-ex",
"set mem inaccessible-by-default off",
],
GDBPYOPTS=[
"-ex",
"source debug/FreeRTOS/FreeRTOS.py",
"-ex",
"source debug/PyCortexMDebug/PyCortexMDebug.py",
"-ex",
"svd_load ${SVD_FILE}",
"-ex",
"compare-sections",
],
ENV=os.environ,
)
firmware_out = distenv.AddFwProject(
firmware_env = distenv.AddFwProject(
base_env=coreenv,
fw_type="firmware",
fw_env_key="FW_ENV",
@ -44,7 +70,7 @@ firmware_out = distenv.AddFwProject(
# If enabled, initialize updater-related targets
if GetOption("fullenv"):
updater_out = distenv.AddFwProject(
updater_env = distenv.AddFwProject(
base_env=coreenv,
fw_type="updater",
fw_env_key="UPD_ENV",
@ -72,19 +98,32 @@ if GetOption("fullenv"):
selfupdate_dist = distenv.DistCommand(
"updater_package",
(distenv["DIST_DEPENDS"], firmware_out["FW_RESOURCES"]),
(distenv["DIST_DEPENDS"], firmware_env["FW_RESOURCES"]),
DIST_EXTRA=dist_arguments,
)
# Updater debug
distenv.AddDebugTarget("updater_debug", updater_out, False)
distenv.PhonyTarget(
"updater_debug",
"${GDBPYCOM}",
source=updater_env["FW_ELF"],
GDBREMOTE="${OPENOCD_GDB_PIPE}",
)
distenv.PhonyTarget(
"updater_blackmagic",
"${GDBPYCOM}",
source=updater_env["FW_ELF"],
GDBOPTS=distenv.subst("$GDBOPTS_BLACKMAGIC"),
GDBREMOTE="${BLACKMAGIC_ADDR}",
)
# Installation over USB & CLI
usb_update_package = distenv.UsbInstall(
"#build/usbinstall.flag",
(
distenv["DIST_DEPENDS"],
firmware_out["FW_RESOURCES"],
firmware_env["FW_RESOURCES"],
selfupdate_dist,
),
)
@ -104,15 +143,47 @@ copro_dist = distenv.CoproBuilder(
)
distenv.Alias("copro_dist", copro_dist)
firmware_flash = distenv.AddOpenOCDFlashTarget(firmware_env)
distenv.Alias("flash", firmware_flash)
firmware_bm_flash = distenv.PhonyTarget(
"flash_blackmagic",
"$GDB $GDBOPTS $SOURCES $GDBFLASH",
source=firmware_env["FW_ELF"],
GDBOPTS="${GDBOPTS_BASE} ${GDBOPTS_BLACKMAGIC}",
GDBREMOTE="${BLACKMAGIC_ADDR}",
GDBFLASH=[
"-ex",
"load",
"-ex",
"quit",
],
)
# Debugging firmware
distenv.AddDebugTarget("debug", firmware_out)
firmware_debug = distenv.PhonyTarget(
"debug",
"${GDBPYCOM}",
source=firmware_env["FW_ELF"],
GDBOPTS="${GDBOPTS_BASE}",
GDBREMOTE="${OPENOCD_GDB_PIPE}",
)
distenv.Depends(firmware_debug, firmware_flash)
distenv.PhonyTarget(
"blackmagic",
"${GDBPYCOM}",
source=firmware_env["FW_ELF"],
GDBOPTS="${GDBOPTS_BASE} ${GDBOPTS_BLACKMAGIC}",
GDBREMOTE="${BLACKMAGIC_ADDR}",
)
# Debug alien elf
distenv.PhonyTarget(
"debug_other",
"$GDBPYCOM",
GDBPYOPTS=
# '-ex "source ${ROOT_DIR.abspath}/debug/FreeRTOS/FreeRTOS.py" '
'-ex "source debug/PyCortexMDebug/PyCortexMDebug.py" ',
"${GDBPYCOM}",
GDBPYOPTS='-ex "source debug/PyCortexMDebug/PyCortexMDebug.py" ',
GDBREMOTE="${OPENOCD_GDB_PIPE}",
)
# Just start OpenOCD
@ -125,11 +196,19 @@ distenv.PhonyTarget(
distenv.PhonyTarget(
"lint",
"${PYTHON3} scripts/lint.py check ${LINT_SOURCES}",
LINT_SOURCES=firmware_out["LINT_SOURCES"],
LINT_SOURCES=firmware_env["LINT_SOURCES"],
)
distenv.PhonyTarget(
"format",
"${PYTHON3} scripts/lint.py format ${LINT_SOURCES}",
LINT_SOURCES=firmware_out["LINT_SOURCES"],
LINT_SOURCES=firmware_env["LINT_SOURCES"],
)
# Find blackmagic probe
distenv.PhonyTarget(
"get_blackmagic",
"@echo $( ${BLACKMAGIC_ADDR} $)",
)

12
applications/desktop/helpers/slideshow.c
View file

@ -12,6 +12,7 @@
struct Slideshow {
Icon icon;
uint32_t current_frame;
bool loaded;
};
#pragma pack(push, 1)
@ -34,6 +35,7 @@ _Static_assert(sizeof(SlideshowFrameHeader) == 2, "Incorrect SlideshowFrameHeade
Slideshow* slideshow_alloc() {
Slideshow* ret = malloc(sizeof(Slideshow));
ret->loaded = false;
return ret;
}
@ -52,7 +54,7 @@ void slideshow_free(Slideshow* slideshow) {
bool slideshow_load(Slideshow* slideshow, const char* fspath) {
Storage* storage = furi_record_open("storage");
File* slideshow_file = storage_file_alloc(storage);
bool load_success = false;
slideshow->loaded = false;
do {
if(!storage_file_open(slideshow_file, fspath, FSAM_READ, FSOM_OPEN_EXISTING)) {
break;
@ -80,12 +82,16 @@ bool slideshow_load(Slideshow* slideshow, const char* fspath) {
frame_header.size) {
break;
}
load_success = (frame_idx + 1) == header.frame_count;
slideshow->loaded = (frame_idx + 1) == header.frame_count;
}
} while(false);
storage_file_free(slideshow_file);
furi_record_close("storage");
return load_success;
return slideshow->loaded;
}
bool slideshow_is_loaded(Slideshow* slideshow) {
return slideshow->loaded;
}
bool slideshow_advance(Slideshow* slideshow) {

1
applications/desktop/helpers/slideshow.h
View file

@ -8,6 +8,7 @@ Slideshow* slideshow_alloc();
void slideshow_free(Slideshow* slideshow);
bool slideshow_load(Slideshow* slideshow, const char* fspath);
bool slideshow_is_loaded(Slideshow* slideshow);
void slideshow_goback(Slideshow* slideshow);
bool slideshow_advance(Slideshow* slideshow);
void slideshow_draw(Slideshow* slideshow, Canvas* canvas, uint8_t x, uint8_t y);

4
applications/desktop/views/desktop_view_slideshow.c
View file

@ -21,7 +21,9 @@ static void desktop_view_slideshow_draw(Canvas* canvas, void* model) {
DesktopSlideshowViewModel* m = model;
canvas_clear(canvas);
slideshow_draw(m->slideshow, canvas, 0, 0);
if(slideshow_is_loaded(m->slideshow)) {
slideshow_draw(m->slideshow, canvas, 0, 0);
}
}
static bool desktop_view_slideshow_input(InputEvent* event, void* context) {

2
applications/gpio/usb_uart_bridge.c
View file

@ -85,7 +85,6 @@ static void usb_uart_on_irq_cb(UartIrqEvent ev, uint8_t data, void* context) {
static void usb_uart_vcp_init(UsbUartBridge* usb_uart, uint8_t vcp_ch) {
furi_hal_usb_unlock();
FURI_LOG_I("", "Init %d", vcp_ch);
if(vcp_ch == 0) {
Cli* cli = furi_record_open("cli");
cli_session_close(cli);
@ -103,7 +102,6 @@ static void usb_uart_vcp_init(UsbUartBridge* usb_uart, uint8_t vcp_ch) {
static void usb_uart_vcp_deinit(UsbUartBridge* usb_uart, uint8_t vcp_ch) {
UNUSED(usb_uart);
furi_hal_cdc_set_callbacks(vcp_ch, NULL, NULL);
FURI_LOG_I("", "Deinit %d", vcp_ch);
if(vcp_ch != 0) {
Cli* cli = furi_record_open("cli");
cli_session_close(cli);

60
applications/ibutton/ibutton.c
View file

@ -5,6 +5,9 @@
#include "m-string.h"
#include <toolbox/path.h>
#include <flipper_format/flipper_format.h>
#include "rpc/rpc_app.h"
#define TAG "iButtonApp"
static const NotificationSequence sequence_blink_start_cyan = {
&message_blink_start_10,
@ -55,7 +58,7 @@ static void ibutton_make_app_folder(iButton* ibutton) {
}
}
static bool ibutton_load_key_data(iButton* ibutton, string_t key_path) {
static bool ibutton_load_key_data(iButton* ibutton, string_t key_path, bool show_dialog) {
FlipperFormat* file = flipper_format_file_alloc(ibutton->storage);
bool result = false;
string_t data;
@ -89,13 +92,40 @@ static bool ibutton_load_key_data(iButton* ibutton, string_t key_path) {
flipper_format_free(file);
string_clear(data);
if(!result) {
if((!result) && (show_dialog)) {
dialog_message_show_storage_error(ibutton->dialogs, "Cannot load\nkey file");
}
return result;
}
static bool ibutton_rpc_command_callback(RpcAppSystemEvent event, const char* arg, void* context) {
furi_assert(context);
iButton* ibutton = context;
bool result = false;
if(event == RpcAppEventSessionClose) {
rpc_system_app_set_callback(ibutton->rpc_ctx, NULL, NULL);
ibutton->rpc_ctx = NULL;
view_dispatcher_send_custom_event(ibutton->view_dispatcher, iButtonCustomEventRpcExit);
result = true;
} else if(event == RpcAppEventAppExit) {
view_dispatcher_send_custom_event(ibutton->view_dispatcher, iButtonCustomEventRpcExit);
result = true;
} else if(event == RpcAppEventLoadFile) {
if(arg) {
string_set_str(ibutton->file_path, arg);
if(ibutton_load_key_data(ibutton, ibutton->file_path, false)) {
ibutton_worker_emulate_start(ibutton->key_worker, ibutton->key);
result = true;
}
}
}
return result;
}
bool ibutton_custom_event_callback(void* context, uint32_t event) {
furi_assert(context);
iButton* ibutton = context;
@ -226,7 +256,7 @@ bool ibutton_file_select(iButton* ibutton) {
true);
if(success) {
success = ibutton_load_key_data(ibutton, ibutton->file_path);
success = ibutton_load_key_data(ibutton, ibutton->file_path, true);
}
return success;
@ -334,16 +364,27 @@ int32_t ibutton_app(void* p) {
ibutton_make_app_folder(ibutton);
bool key_loaded = false;
bool rpc_mode = false;
if(p) {
string_set_str(ibutton->file_path, (const char*)p);
if(ibutton_load_key_data(ibutton, ibutton->file_path)) {
key_loaded = true;
// TODO: Display an error if the key from p could not be loaded
uint32_t rpc_ctx = 0;
if(sscanf(p, "RPC %lX", &rpc_ctx) == 1) {
FURI_LOG_D(TAG, "Running in RPC mode");
ibutton->rpc_ctx = (void*)rpc_ctx;
rpc_mode = true;
rpc_system_app_set_callback(ibutton->rpc_ctx, ibutton_rpc_command_callback, ibutton);
} else {
string_set_str(ibutton->file_path, (const char*)p);
if(ibutton_load_key_data(ibutton, ibutton->file_path, true)) {
key_loaded = true;
// TODO: Display an error if the key from p could not be loaded
}
}
}
if(key_loaded) {
if(rpc_mode) {
scene_manager_next_scene(ibutton->scene_manager, iButtonSceneRpc);
} else if(key_loaded) {
scene_manager_next_scene(ibutton->scene_manager, iButtonSceneEmulate);
} else {
scene_manager_next_scene(ibutton->scene_manager, iButtonSceneStart);
@ -351,6 +392,9 @@ int32_t ibutton_app(void* p) {
view_dispatcher_run(ibutton->view_dispatcher);
if(ibutton->rpc_ctx) {
rpc_system_app_set_callback(ibutton->rpc_ctx, NULL, NULL);
}
ibutton_free(ibutton);
return 0;
}

2
applications/ibutton/ibutton_custom_event.h
View file

@ -9,4 +9,6 @@ enum iButtonCustomEvent {
iButtonCustomEventByteEditResult,
iButtonCustomEventWorkerEmulated,
iButtonCustomEventWorkerRead,
iButtonCustomEventRpcExit,
};

2
applications/ibutton/ibutton_i.h
View file

@ -50,6 +50,8 @@ struct iButton {
Popup* popup;
Widget* widget;
DialogEx* dialog_ex;
void* rpc_ctx;
};
typedef enum {

1
applications/ibutton/scenes/ibutton_scene_config.h
View file

@ -18,3 +18,4 @@ ADD_SCENE(ibutton, delete_confirm, DeleteConfirm)
ADD_SCENE(ibutton, delete_success, DeleteSuccess)
ADD_SCENE(ibutton, retry_confirm, RetryConfirm)
ADD_SCENE(ibutton, exit_confirm, ExitConfirm)
ADD_SCENE(ibutton, rpc, Rpc)

36
applications/ibutton/scenes/ibutton_scene_rpc.c Normal file
View file

@ -0,0 +1,36 @@
#include "../ibutton_i.h"
#include <toolbox/path.h>
void ibutton_scene_rpc_on_enter(void* context) {
iButton* ibutton = context;
Widget* widget = ibutton->widget;
widget_add_text_box_element(
widget, 0, 0, 128, 28, AlignCenter, AlignCenter, "RPC mode", false);
view_dispatcher_switch_to_view(ibutton->view_dispatcher, iButtonViewWidget);
notification_message(ibutton->notifications, &sequence_display_backlight_on);
}
bool ibutton_scene_rpc_on_event(void* context, SceneManagerEvent event) {
UNUSED(context);
UNUSED(event);
iButton* ibutton = context;
bool consumed = false;
if(event.type == SceneManagerEventTypeCustom) {
consumed = true;
if(event.event == iButtonCustomEventRpcExit) {
view_dispatcher_stop(ibutton->view_dispatcher);
}
}
return consumed;
}
void ibutton_scene_rpc_on_exit(void* context) {
iButton* ibutton = context;
widget_reset(ibutton->widget);
}

76
applications/infrared/infrared.c
View file

@ -36,6 +36,52 @@ static void infrared_tick_event_callback(void* context) {
scene_manager_handle_tick_event(infrared->scene_manager);
}
static bool
infrared_rpc_command_callback(RpcAppSystemEvent event, const char* arg, void* context) {
furi_assert(context);
Infrared* infrared = context;
if(!infrared->rpc_ctx) {
return false;
}
bool result = false;
if(event == RpcAppEventSessionClose) {
rpc_system_app_set_callback(infrared->rpc_ctx, NULL, NULL);
infrared->rpc_ctx = NULL;
view_dispatcher_send_custom_event(
infrared->view_dispatcher, InfraredCustomEventTypeBackPressed);
result = true;
} else if(event == RpcAppEventAppExit) {
view_dispatcher_send_custom_event(
infrared->view_dispatcher, InfraredCustomEventTypeBackPressed);
result = true;
} else if(event == RpcAppEventLoadFile) {
if(arg) {
string_set_str(infrared->file_path, arg);
result = infrared_remote_load(infrared->remote, infrared->file_path);
infrared_worker_tx_set_get_signal_callback(
infrared->worker, infrared_worker_tx_get_signal_steady_callback, infrared);
infrared_worker_tx_set_signal_sent_callback(
infrared->worker, infrared_signal_sent_callback, infrared);
}
} else if(event == RpcAppEventButtonPress) {
if(arg) {
size_t button_index = 0;
if(infrared_remote_find_button_by_name(infrared->remote, arg, &button_index)) {
infrared_tx_start_button_index(infrared, button_index);
result = true;
}
}
} else if(event == RpcAppEventButtonRelease) {
infrared_tx_stop(infrared);
result = true;
}
return result;
}
static void infrared_find_vacant_remote_name(string_t name, const char* path) {
Storage* storage = furi_record_open("storage");
@ -154,6 +200,11 @@ static void infrared_free(Infrared* infrared) {
ViewDispatcher* view_dispatcher = infrared->view_dispatcher;
InfraredAppState* app_state = &infrared->app_state;
if(infrared->rpc_ctx) {
rpc_system_app_set_callback(infrared->rpc_ctx, NULL, NULL);
infrared->rpc_ctx = NULL;
}
view_dispatcher_remove_view(view_dispatcher, InfraredViewSubmenu);
submenu_free(infrared->submenu);
@ -375,18 +426,29 @@ int32_t infrared_app(void* p) {
infrared_make_app_folder(infrared);
bool is_remote_loaded = false;
bool is_rpc_mode = false;
if(p) {
string_set_str(infrared->file_path, (const char*)p);
is_remote_loaded = infrared_remote_load(infrared->remote, infrared->file_path);
if(!is_remote_loaded) {
dialog_message_show_storage_error(
infrared->dialogs, "Failed to load\nselected remote");
return -1;
uint32_t rpc_ctx = 0;
if(sscanf(p, "RPC %lX", &rpc_ctx) == 1) {
infrared->rpc_ctx = (void*)rpc_ctx;
rpc_system_app_set_callback(
infrared->rpc_ctx, infrared_rpc_command_callback, infrared);
is_rpc_mode = true;
} else {
string_set_str(infrared->file_path, (const char*)p);
is_remote_loaded = infrared_remote_load(infrared->remote, infrared->file_path);
if(!is_remote_loaded) {
dialog_message_show_storage_error(
infrared->dialogs, "Failed to load\nselected remote");
return -1;
}
}
}
if(is_remote_loaded) {
if(is_rpc_mode) {
scene_manager_next_scene(infrared->scene_manager, InfraredSceneRpc);
} else if(is_remote_loaded) {
scene_manager_next_scene(infrared->scene_manager, InfraredSceneRemote);
} else {
scene_manager_next_scene(infrared->scene_manager, InfraredSceneStart);

4
applications/infrared/infrared_i.h
View file

@ -30,6 +30,8 @@
#include "views/infrared_progress_view.h"
#include "views/infrared_debug_view.h"
#include "rpc/rpc_app.h"
#define INFRARED_FILE_NAME_SIZE 100
#define INFRARED_TEXT_STORE_NUM 2
#define INFRARED_TEXT_STORE_SIZE 128
@ -95,6 +97,8 @@ struct Infrared {
string_t file_path;
char text_store[INFRARED_TEXT_STORE_NUM][INFRARED_TEXT_STORE_SIZE + 1];
InfraredAppState app_state;
void* rpc_ctx;
};
typedef enum {

13
applications/infrared/infrared_remote.c
View file

@ -1,5 +1,7 @@
#include "infrared_remote.h"
#include <stdbool.h>
#include <stddef.h>
#include <stdlib.h>
#include <m-string.h>
#include <m-array.h>
@ -73,6 +75,17 @@ InfraredRemoteButton* infrared_remote_get_button(InfraredRemote* remote, size_t
return *InfraredButtonArray_get(remote->buttons, index);
}
bool infrared_remote_find_button_by_name(InfraredRemote* remote, const char* name, size_t* index) {
for(size_t i = 0; i < InfraredButtonArray_size(remote->buttons); i++) {
InfraredRemoteButton* button = *InfraredButtonArray_get(remote->buttons, i);
if(!strcmp(infrared_remote_button_get_name(button), name)) {
*index = i;
return true;
}
}
return false;
}
bool infrared_remote_add_button(InfraredRemote* remote, const char* name, InfraredSignal* signal) {
InfraredRemoteButton* button = infrared_remote_button_alloc();
infrared_remote_button_set_name(button, name);

1
applications/infrared/infrared_remote.h
View file

@ -18,6 +18,7 @@ const char* infrared_remote_get_path(InfraredRemote* remote);
size_t infrared_remote_get_button_count(InfraredRemote* remote);
InfraredRemoteButton* infrared_remote_get_button(InfraredRemote* remote, size_t index);
bool infrared_remote_find_button_by_name(InfraredRemote* remote, const char* name, size_t* index);
bool infrared_remote_add_button(InfraredRemote* remote, const char* name, InfraredSignal* signal);
bool infrared_remote_rename_button(InfraredRemote* remote, const char* new_name, size_t index);

1
applications/infrared/scenes/infrared_scene_config.h
View file

@ -16,3 +16,4 @@ ADD_SCENE(infrared, universal, Universal)
ADD_SCENE(infrared, universal_tv, UniversalTV)
ADD_SCENE(infrared, debug, Debug)
ADD_SCENE(infrared, error_databases, ErrorDatabases)
ADD_SCENE(infrared, rpc, Rpc)

37
applications/infrared/scenes/infrared_scene_rpc.c Normal file
View file

@ -0,0 +1,37 @@
#include "../infrared_i.h"
#include "gui/canvas.h"
void infrared_scene_rpc_on_enter(void* context) {
Infrared* infrared = context;
Popup* popup = infrared->popup;
popup_set_text(popup, "Rpc mode", 64, 28, AlignCenter, AlignCenter);
popup_set_context(popup, context);
popup_set_callback(popup, infrared_popup_closed_callback);
infrared_play_notification_message(infrared, InfraredNotificationMessageYellowOn);
view_dispatcher_switch_to_view(infrared->view_dispatcher, InfraredViewPopup);
notification_message(infrared->notifications, &sequence_display_backlight_on);
}
bool infrared_scene_rpc_on_event(void* context, SceneManagerEvent event) {
Infrared* infrared = context;
bool consumed = false;
if(event.type == SceneManagerEventTypeCustom) {
consumed = true;
if(event.event == InfraredCustomEventTypeBackPressed) {
view_dispatcher_stop(infrared->view_dispatcher);
} else if(event.event == InfraredCustomEventTypePopupClosed) {
view_dispatcher_stop(infrared->view_dispatcher);
}
}
return consumed;
}
void infrared_scene_rpc_on_exit(void* context) {
Infrared* infrared = context;
popup_reset(infrared->popup);
}

63
applications/lfrfid/lfrfid_app.cpp
View file

@ -20,10 +20,13 @@
#include "scene/lfrfid_app_scene_saved_info.h"
#include "scene/lfrfid_app_scene_delete_confirm.h"
#include "scene/lfrfid_app_scene_delete_success.h"
#include "scene/lfrfid_app_scene_rpc.h"
#include <toolbox/path.h>
#include <flipper_format/flipper_format.h>
#include "rpc/rpc_app.h"
const char* LfRfidApp::app_folder = "/any/lfrfid";
const char* LfRfidApp::app_extension = ".rfid";
const char* LfRfidApp::app_filetype = "Flipper RFID key";
@ -39,6 +42,43 @@ LfRfidApp::LfRfidApp()
LfRfidApp::~LfRfidApp() {
string_clear(file_path);
if(rpc_ctx) {
rpc_system_app_set_callback(rpc_ctx, NULL, NULL);
}
}
static bool rpc_command_callback(RpcAppSystemEvent event, const char* arg, void* context) {
furi_assert(context);
LfRfidApp* app = static_cast<LfRfidApp*>(context);
bool result = false;
if(event == RpcAppEventSessionClose) {
rpc_system_app_set_callback(app->rpc_ctx, NULL, NULL);
app->rpc_ctx = NULL;
LfRfidApp::Event event;
event.type = LfRfidApp::EventType::Exit;
app->view_controller.send_event(&event);
result = true;
} else if(event == RpcAppEventAppExit) {
LfRfidApp::Event event;
event.type = LfRfidApp::EventType::Exit;
app->view_controller.send_event(&event);
result = true;
} else if(event == RpcAppEventLoadFile) {
if(arg) {
string_set_str(app->file_path, arg);
if(app->load_key_data(app->file_path, &(app->worker.key), false)) {
LfRfidApp::Event event;
event.type = LfRfidApp::EventType::EmulateStart;
app->view_controller.send_event(&event);
app->worker.start_emulate();
result = true;
}
}
}
return result;
}
void LfRfidApp::run(void* _args) {
@ -47,10 +87,19 @@ void LfRfidApp::run(void* _args) {
make_app_folder();
if(strlen(args)) {
string_set_str(file_path, args);
load_key_data(file_path, &worker.key);
scene_controller.add_scene(SceneType::Emulate, new LfRfidAppSceneEmulate());
scene_controller.process(100, SceneType::Emulate);
uint32_t rpc_ctx_ptr = 0;
if(sscanf(args, "RPC %lX", &rpc_ctx_ptr) == 1) {
rpc_ctx = (RpcAppSystem*)rpc_ctx_ptr;
rpc_system_app_set_callback(rpc_ctx, rpc_command_callback, this);
scene_controller.add_scene(SceneType::Rpc, new LfRfidAppSceneRpc());
scene_controller.process(100, SceneType::Rpc);
} else {
string_set_str(file_path, args);
load_key_data(file_path, &worker.key, true);
scene_controller.add_scene(SceneType::Emulate, new LfRfidAppSceneEmulate());
scene_controller.process(100, SceneType::Emulate);
}
} else {
scene_controller.add_scene(SceneType::Start, new LfRfidAppSceneStart());
scene_controller.add_scene(SceneType::Read, new LfRfidAppSceneRead());
@ -99,7 +148,7 @@ bool LfRfidApp::load_key_from_file_select(bool need_restore) {
dialogs, file_path, file_path, app_extension, true, &I_125_10px, true);
if(result) {
result = load_key_data(file_path, &worker.key);
result = load_key_data(file_path, &worker.key, true);
}
return result;
@ -110,7 +159,7 @@ bool LfRfidApp::delete_key(RfidKey* key) {
return storage_simply_remove(storage, string_get_cstr(file_path));
}
bool LfRfidApp::load_key_data(string_t path, RfidKey* key) {
bool LfRfidApp::load_key_data(string_t path, RfidKey* key, bool show_dialog) {
FlipperFormat* file = flipper_format_file_alloc(storage);
bool result = false;
string_t str_result;
@ -149,7 +198,7 @@ bool LfRfidApp::load_key_data(string_t path, RfidKey* key) {
flipper_format_free(file);
string_clear(str_result);
if(!result) {
if((!result) && (show_dialog)) {
dialog_message_show_storage_error(dialogs, "Cannot load\nkey file");
}

9
applications/lfrfid/lfrfid_app.h
View file

@ -21,6 +21,7 @@
#include <dialogs/dialogs.h>
#include "helpers/rfid_worker.h"
#include "rpc/rpc_app.h"
class LfRfidApp {
public:
@ -30,6 +31,8 @@ public:
MenuSelected,
Stay,
Retry,
Exit,
EmulateStart,
};
enum class SceneType : uint8_t {
@ -51,6 +54,7 @@ public:
SavedInfo,
DeleteConfirm,
DeleteSuccess,
Rpc,
};
class Event {
@ -79,6 +83,8 @@ public:
string_t file_path;
RpcAppSystem* rpc_ctx;
void run(void* args);
static const char* app_folder;
@ -89,8 +95,9 @@ public:
bool load_key_from_file_select(bool need_restore);
bool delete_key(RfidKey* key);
bool load_key_data(string_t path, RfidKey* key);
bool load_key_data(string_t path, RfidKey* key, bool show_dialog);
bool save_key_data(string_t path, RfidKey* key);
void make_app_folder();
//bool rpc_command_callback(RpcAppSystemEvent event, const char* arg, void* context);
};

37
applications/lfrfid/scene/lfrfid_app_scene_rpc.cpp Normal file
View file

@ -0,0 +1,37 @@
#include "lfrfid_app_scene_rpc.h"
#include "furi/common_defines.h"
#include <dolphin/dolphin.h>
void LfRfidAppSceneRpc::on_enter(LfRfidApp* app, bool /* need_restore */) {
auto popup = app->view_controller.get<PopupVM>();
popup->set_header("RPC Mode", 64, 30, AlignCenter, AlignTop);
app->view_controller.switch_to<PopupVM>();
notification_message(app->notification, &sequence_display_backlight_on);
}
bool LfRfidAppSceneRpc::on_event(LfRfidApp* app, LfRfidApp::Event* event) {
UNUSED(app);
UNUSED(event);
bool consumed = false;
if(event->type == LfRfidApp::EventType::Exit) {
consumed = true;
LfRfidApp::Event view_event;
view_event.type = LfRfidApp::EventType::Back;
app->view_controller.send_event(&view_event);
} else if(event->type == LfRfidApp::EventType::EmulateStart) {
consumed = true;
emulating = true;
}
return consumed;
}
void LfRfidAppSceneRpc::on_exit(LfRfidApp* app) {
if(emulating) {
app->worker.stop_emulate();
}
app->view_controller.get<PopupVM>()->clean();
}

12
applications/lfrfid/scene/lfrfid_app_scene_rpc.h Normal file
View file

@ -0,0 +1,12 @@
#pragma once
#include "../lfrfid_app.h"
class LfRfidAppSceneRpc : public GenericScene<LfRfidApp> {
public:
void on_enter(LfRfidApp* app, bool need_restore) final;
bool on_event(LfRfidApp* app, LfRfidApp::Event* event) final;
void on_exit(LfRfidApp* app) final;
private:
bool emulating = false;
};

78
applications/nfc/nfc.c Executable file → Normal file
View file

@ -19,6 +19,77 @@ void nfc_tick_event_callback(void* context) {
scene_manager_handle_tick_event(nfc->scene_manager);
}
void nfc_rpc_exit_callback(Nfc* nfc) {
if(nfc->rpc_state == NfcRpcStateEmulating) {
// Stop worker
nfc_worker_stop(nfc->worker);
} else if(nfc->rpc_state == NfcRpcStateEmulated) {
// Stop worker
nfc_worker_stop(nfc->worker);
// Save data in shadow file
nfc_device_save_shadow(nfc->dev, nfc->dev->dev_name);
}
if(nfc->rpc_ctx) {
rpc_system_app_set_callback(nfc->rpc_ctx, NULL, NULL);
nfc->rpc_ctx = NULL;
}
}
static void nfc_rpc_emulate_callback(NfcWorkerEvent event, void* context) {
UNUSED(event);
Nfc* nfc = context;
nfc->rpc_state = NfcRpcStateEmulated;
}
static bool nfc_rpc_command_callback(RpcAppSystemEvent event, const char* arg, void* context) {
furi_assert(context);
Nfc* nfc = context;
if(!nfc->rpc_ctx) {
return false;
}
bool result = false;
if(event == RpcAppEventSessionClose) {
rpc_system_app_set_callback(nfc->rpc_ctx, NULL, NULL);
nfc->rpc_ctx = NULL;
view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
result = true;
} else if(event == RpcAppEventAppExit) {
view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
result = true;
} else if(event == RpcAppEventLoadFile) {
if((arg) && (nfc->rpc_state == NfcRpcStateIdle)) {
if(nfc_device_load(nfc->dev, arg, false)) {
if(nfc->dev->format == NfcDeviceSaveFormatMifareUl) {
nfc_worker_start(
nfc->worker,
NfcWorkerStateEmulateMifareUltralight,
&nfc->dev->dev_data,
nfc_rpc_emulate_callback,
nfc);
} else if(nfc->dev->format == NfcDeviceSaveFormatMifareClassic) {
nfc_worker_start(
nfc->worker,
NfcWorkerStateEmulateMifareClassic,
&nfc->dev->dev_data,
nfc_rpc_emulate_callback,
nfc);
} else {
nfc_worker_start(
nfc->worker, NfcWorkerStateEmulate, &nfc->dev->dev_data, NULL, nfc);
}
nfc->rpc_state = NfcRpcStateEmulating;
result = true;
}
}
}
return result;
}
Nfc* nfc_alloc() {
Nfc* nfc = malloc(sizeof(Nfc));
@ -193,7 +264,12 @@ int32_t nfc_app(void* p) {
// Check argument and run corresponding scene
if((*args != '\0')) {
if(nfc_device_load(nfc->dev, p)) {
uint32_t rpc_ctx = 0;
if(sscanf(p, "RPC %lX", &rpc_ctx) == 1) {
nfc->rpc_ctx = (void*)rpc_ctx;
rpc_system_app_set_callback(nfc->rpc_ctx, nfc_rpc_command_callback, nfc);
scene_manager_next_scene(nfc->scene_manager, NfcSceneRpc);
} else if(nfc_device_load(nfc->dev, p, true)) {
if(nfc->dev->format == NfcDeviceSaveFormatMifareUl) {
scene_manager_next_scene(nfc->scene_manager, NfcSceneEmulateMifareUl);
} else if(nfc->dev->format == NfcDeviceSaveFormatMifareClassic) {

12
applications/nfc/nfc_device.c
View file

@ -837,7 +837,7 @@ bool nfc_device_save_shadow(NfcDevice* dev, const char* dev_name) {
return nfc_device_save_file(dev, dev_name, NFC_APP_FOLDER, NFC_APP_SHADOW_EXTENSION, true);
}
static bool nfc_device_load_data(NfcDevice* dev, string_t path) {
static bool nfc_device_load_data(NfcDevice* dev, string_t path, bool show_dialog) {
bool parsed = false;
FlipperFormat* file = flipper_format_file_alloc(dev->storage);
FuriHalNfcDevData* data = &dev->dev_data.nfc_data;
@ -887,7 +887,7 @@ static bool nfc_device_load_data(NfcDevice* dev, string_t path) {
parsed = true;
} while(false);
if(!parsed) {
if((!parsed) && (show_dialog)) {
if(deprecated_version) {
dialog_message_show_storage_error(dev->dialogs, "File format deprecated");
} else {
@ -900,13 +900,13 @@ static bool nfc_device_load_data(NfcDevice* dev, string_t path) {
return parsed;
}
bool nfc_device_load(NfcDevice* dev, const char* file_path) {
bool nfc_device_load(NfcDevice* dev, const char* file_path, bool show_dialog) {
furi_assert(dev);
furi_assert(file_path);
// Load device data
string_set_str(dev->load_path, file_path);
bool dev_load = nfc_device_load_data(dev, dev->load_path);
bool dev_load = nfc_device_load_data(dev, dev->load_path, show_dialog);
if(dev_load) {
// Set device name
string_t filename;
@ -933,7 +933,7 @@ bool nfc_file_select(NfcDevice* dev) {
string_init(filename);
path_extract_filename(dev->load_path, filename, true);
strncpy(dev->dev_name, string_get_cstr(filename), NFC_DEV_NAME_MAX_LEN);
res = nfc_device_load_data(dev, dev->load_path);
res = nfc_device_load_data(dev, dev->load_path, true);
if(res) {
nfc_device_set_name(dev, dev->dev_name);
}
@ -1017,7 +1017,7 @@ bool nfc_device_restore(NfcDevice* dev, bool use_load_path) {
} else {
string_printf(path, "%s/%s%s", NFC_APP_FOLDER, dev->dev_name, NFC_APP_EXTENSION);
}
if(!nfc_device_load_data(dev, path)) break;
if(!nfc_device_load_data(dev, path, true)) break;
restored = true;
} while(0);

2
applications/nfc/nfc_device.h
View file

@ -71,7 +71,7 @@ bool nfc_device_save(NfcDevice* dev, const char* dev_name);
bool nfc_device_save_shadow(NfcDevice* dev, const char* dev_name);
bool nfc_device_load(NfcDevice* dev, const char* file_path);
bool nfc_device_load(NfcDevice* dev, const char* file_path, bool show_dialog);
bool nfc_file_select(NfcDevice* dev);

13
applications/nfc/nfc_i.h
View file

@ -29,10 +29,18 @@
#include <nfc/scenes/nfc_scene.h>
#include <nfc/helpers/nfc_custom_event.h>
#include "rpc/rpc_app.h"
#define NFC_SEND_NOTIFICATION_FALSE (0UL)
#define NFC_SEND_NOTIFICATION_TRUE (1UL)
#define NFC_TEXT_STORE_SIZE 128
typedef enum {
NfcRpcStateIdle,
NfcRpcStateEmulating,
NfcRpcStateEmulated,
} NfcRpcState;
// Forward declaration due to circular dependency
typedef struct NfcGenerator NfcGenerator;
@ -48,6 +56,9 @@ struct Nfc {
char text_store[NFC_TEXT_STORE_SIZE + 1];
string_t text_box_store;
void* rpc_ctx;
NfcRpcState rpc_state;
// Common Views
Submenu* submenu;
DialogEx* dialog_ex;
@ -85,3 +96,5 @@ void nfc_text_store_clear(Nfc* nfc);
void nfc_blink_start(Nfc* nfc);
void nfc_blink_stop(Nfc* nfc);
void nfc_rpc_exit_callback(Nfc* nfc);

1
applications/nfc/scenes/nfc_scene_config.h
View file

@ -37,4 +37,5 @@ ADD_SCENE(nfc, read_mifare_classic, ReadMifareClassic)
ADD_SCENE(nfc, emulate_mifare_classic, EmulateMifareClassic)
ADD_SCENE(nfc, mifare_classic_menu, MifareClassicMenu)
ADD_SCENE(nfc, dict_not_found, DictNotFound)
ADD_SCENE(nfc, rpc, Rpc)
ADD_SCENE(nfc, generate_info, GenerateInfo)

34
applications/nfc/scenes/nfc_scene_rpc.c Normal file
View file

@ -0,0 +1,34 @@
#include "../nfc_i.h"
void nfc_scene_rpc_on_enter(void* context) {
Nfc* nfc = context;
Widget* widget = nfc->widget;
widget_add_text_box_element(
widget, 0, 0, 128, 28, AlignCenter, AlignCenter, "RPC mode", false);
notification_message(nfc->notifications, &sequence_display_backlight_on);
view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
}
bool nfc_scene_rpc_on_event(void* context, SceneManagerEvent event) {
Nfc* nfc = context;
bool consumed = false;
if(event.type == SceneManagerEventTypeCustom) {
consumed = true;
if(event.event == NfcCustomEventViewExit) {
view_dispatcher_stop(nfc->view_dispatcher);
}
}
return consumed;
}
void nfc_scene_rpc_on_exit(void* context) {
Nfc* nfc = context;
nfc_rpc_exit_callback(nfc);
widget_reset(nfc->widget);
}

7
applications/rpc/rpc.c
View file

@ -45,13 +45,16 @@ static RpcSystemCallbacks rpc_systems[] = {
},
{
.alloc = rpc_system_app_alloc,
.free = NULL,
.free = rpc_system_app_free,
},
{
.alloc = rpc_system_gui_alloc,
.free = rpc_system_gui_free,
},
};
{
.alloc = rpc_system_gpio_alloc,
.free = NULL,
}};
struct RpcSession {
Rpc* rpc;

175
applications/rpc/rpc_app.c
View file

@ -1,16 +1,39 @@
#include "cmsis_os2.h"
#include "flipper.pb.h"
#include "furi/record.h"
#include "rpc_i.h"
#include <furi.h>
#include <loader/loader.h>
#include "rpc_app.h"
#define TAG "RpcSystemApp"
#define APP_BUTTON_TIMEOUT 1000
struct RpcAppSystem {
RpcSession* session;
RpcAppSystemCallback app_callback;
void* app_context;
osTimerId_t timer;
};
static void rpc_system_app_timer_callback(void* context) {
furi_assert(context);
RpcAppSystem* rpc_app = context;
if(rpc_app->app_callback) {
rpc_app->app_callback(RpcAppEventButtonRelease, NULL, rpc_app->app_context);
}
}
static void rpc_system_app_start_process(const PB_Main* request, void* context) {
furi_assert(request);
furi_assert(context);
furi_assert(request->which_content == PB_Main_app_start_request_tag);
RpcSession* session = (RpcSession*)context;
RpcAppSystem* rpc_app = context;
RpcSession* session = rpc_app->session;
furi_assert(session);
char args_temp[16];
FURI_LOG_D(TAG, "Start");
@ -20,6 +43,11 @@ static void rpc_system_app_start_process(const PB_Main* request, void* context)
const char* app_name = request->content.app_start_request.name;
if(app_name) {
const char* app_args = request->content.app_start_request.args;
if(strcmp(app_args, "RPC") == 0) {
// If app is being started in RPC mode - pass RPC context via args string
snprintf(args_temp, 16, "RPC %08lX", (uint32_t)rpc_app);
app_args = args_temp;
}
LoaderStatus status = loader_start(loader, app_name, app_args);
if(status == LoaderStatusErrorAppStarted) {
result = PB_CommandStatus_ERROR_APP_SYSTEM_LOCKED;
@ -43,8 +71,11 @@ static void rpc_system_app_start_process(const PB_Main* request, void* context)
static void rpc_system_app_lock_status_process(const PB_Main* request, void* context) {
furi_assert(request);
furi_assert(context);
furi_assert(request->which_content == PB_Main_app_lock_status_request_tag);
RpcSession* session = (RpcSession*)context;
RpcAppSystem* rpc_app = context;
RpcSession* session = rpc_app->session;
furi_assert(session);
FURI_LOG_D(TAG, "LockStatus");
@ -66,13 +97,123 @@ static void rpc_system_app_lock_status_process(const PB_Main* request, void* con
pb_release(&PB_Main_msg, &response);
}
static void rpc_system_app_exit(const PB_Main* request, void* context) {
furi_assert(request);
furi_assert(context);
furi_assert(request->which_content == PB_Main_app_exit_request_tag);
RpcAppSystem* rpc_app = context;
RpcSession* session = rpc_app->session;
furi_assert(session);
PB_CommandStatus status;
if(rpc_app->app_callback) {
if(rpc_app->app_callback(RpcAppEventAppExit, NULL, rpc_app->app_context)) {
status = PB_CommandStatus_OK;
osTimerStop(rpc_app->timer);
} else {
status = PB_CommandStatus_ERROR_APP_CMD_ERROR;
}
} else {
status = PB_CommandStatus_ERROR_APP_NOT_RUNNING;
}
rpc_send_and_release_empty(session, request->command_id, status);
}
static void rpc_system_app_load_file(const PB_Main* request, void* context) {
furi_assert(request);
furi_assert(context);
furi_assert(request->which_content == PB_Main_app_load_file_request_tag);
RpcAppSystem* rpc_app = context;
RpcSession* session = rpc_app->session;
furi_assert(session);
PB_CommandStatus status;
if(rpc_app->app_callback) {
const char* file_path = request->content.app_load_file_request.path;
if(rpc_app->app_callback(RpcAppEventLoadFile, file_path, rpc_app->app_context)) {
status = PB_CommandStatus_OK;
} else {
status = PB_CommandStatus_ERROR_APP_CMD_ERROR;
}
} else {
status = PB_CommandStatus_ERROR_APP_NOT_RUNNING;
}
rpc_send_and_release_empty(session, request->command_id, status);
}
static void rpc_system_app_button_press(const PB_Main* request, void* context) {
furi_assert(request);
furi_assert(context);
furi_assert(request->which_content == PB_Main_app_button_press_request_tag);
RpcAppSystem* rpc_app = context;
RpcSession* session = rpc_app->session;
furi_assert(session);
PB_CommandStatus status;
if(rpc_app->app_callback) {
const char* args = request->content.app_button_press_request.args;
if(rpc_app->app_callback(RpcAppEventButtonPress, args, rpc_app->app_context)) {
status = PB_CommandStatus_OK;
osTimerStart(rpc_app->timer, APP_BUTTON_TIMEOUT);
} else {
status = PB_CommandStatus_ERROR_APP_CMD_ERROR;
}
} else {
status = PB_CommandStatus_ERROR_APP_NOT_RUNNING;
}
rpc_send_and_release_empty(session, request->command_id, status);
}
static void rpc_system_app_button_release(const PB_Main* request, void* context) {
furi_assert(request);
furi_assert(request->which_content == PB_Main_app_button_release_request_tag);
furi_assert(context);
RpcAppSystem* rpc_app = context;
RpcSession* session = rpc_app->session;
furi_assert(session);
PB_CommandStatus status;
if(rpc_app->app_callback) {
if(rpc_app->app_callback(RpcAppEventButtonRelease, NULL, rpc_app->app_context)) {
status = PB_CommandStatus_OK;
osTimerStop(rpc_app->timer);
} else {
status = PB_CommandStatus_ERROR_APP_CMD_ERROR;
}
} else {
status = PB_CommandStatus_ERROR_APP_NOT_RUNNING;
}
rpc_send_and_release_empty(session, request->command_id, status);
}
void rpc_system_app_set_callback(RpcAppSystem* rpc_app, RpcAppSystemCallback callback, void* ctx) {
furi_assert(rpc_app);
rpc_app->app_callback = callback;
rpc_app->app_context = ctx;
}
void* rpc_system_app_alloc(RpcSession* session) {
furi_assert(session);
RpcAppSystem* rpc_app = malloc(sizeof(RpcAppSystem));
rpc_app->session = session;
rpc_app->timer = osTimerNew(rpc_system_app_timer_callback, osTimerOnce, rpc_app, NULL);
RpcHandler rpc_handler = {
.message_handler = NULL,
.decode_submessage = NULL,
.context = session,
.context = rpc_app,
};
rpc_handler.message_handler = rpc_system_app_start_process;
@ -81,5 +222,31 @@ void* rpc_system_app_alloc(RpcSession* session) {
rpc_handler.message_handler = rpc_system_app_lock_status_process;
rpc_add_handler(session, PB_Main_app_lock_status_request_tag, &rpc_handler);
return NULL;
rpc_handler.message_handler = rpc_system_app_exit;
rpc_add_handler(session, PB_Main_app_exit_request_tag, &rpc_handler);
rpc_handler.message_handler = rpc_system_app_load_file;
rpc_add_handler(session, PB_Main_app_load_file_request_tag, &rpc_handler);
rpc_handler.message_handler = rpc_system_app_button_press;
rpc_add_handler(session, PB_Main_app_button_press_request_tag, &rpc_handler);
rpc_handler.message_handler = rpc_system_app_button_release;
rpc_add_handler(session, PB_Main_app_button_release_request_tag, &rpc_handler);
return rpc_app;
}
void rpc_system_app_free(void* context) {
RpcAppSystem* rpc_app = context;
RpcSession* session = rpc_app->session;
furi_assert(session);
osTimerDelete(rpc_app->timer);
if(rpc_app->app_callback) {
rpc_app->app_callback(RpcAppEventSessionClose, NULL, rpc_app->app_context);
}
free(rpc_app);
}

24
applications/rpc/rpc_app.h Normal file
View file

@ -0,0 +1,24 @@
#pragma once
#include "rpc.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef enum {
RpcAppEventSessionClose,
RpcAppEventAppExit,
RpcAppEventLoadFile,
RpcAppEventButtonPress,
RpcAppEventButtonRelease,
} RpcAppSystemEvent;
typedef bool (*RpcAppSystemCallback)(RpcAppSystemEvent event, const char* arg, void* context);
typedef struct RpcAppSystem RpcAppSystem;
void rpc_system_app_set_callback(RpcAppSystem* rpc_app, RpcAppSystemCallback callback, void* ctx);
#ifdef __cplusplus
}
#endif

221
applications/rpc/rpc_gpio.c Normal file
View file

@ -0,0 +1,221 @@
#include "flipper.pb.h"
#include "rpc_i.h"
#include "gpio.pb.h"
#include <furi_hal_gpio.h>
#include <furi_hal_resources.h>
static const GpioPin* rpc_pin_to_hal_pin(PB_Gpio_GpioPin rpc_pin) {
switch(rpc_pin) {
case PB_Gpio_GpioPin_PC0:
return &gpio_ext_pc0;
case PB_Gpio_GpioPin_PC1:
return &gpio_ext_pc1;
case PB_Gpio_GpioPin_PC3:
return &gpio_ext_pc3;
case PB_Gpio_GpioPin_PB2:
return &gpio_ext_pb2;
case PB_Gpio_GpioPin_PB3:
return &gpio_ext_pb3;
case PB_Gpio_GpioPin_PA4:
return &gpio_ext_pa4;
case PB_Gpio_GpioPin_PA6:
return &gpio_ext_pa6;
case PB_Gpio_GpioPin_PA7:
return &gpio_ext_pa7;
}
__builtin_unreachable();
}
static GpioMode rpc_mode_to_hal_mode(PB_Gpio_GpioPinMode rpc_mode) {
switch(rpc_mode) {
case PB_Gpio_GpioPinMode_OUTPUT:
return GpioModeOutputPushPull;
case PB_Gpio_GpioPinMode_INPUT:
return GpioModeInput;
}
__builtin_unreachable();
}
static GpioPull rpc_pull_mode_to_hall_pull_mode(PB_Gpio_GpioInputPull pull_mode) {
switch(pull_mode) {
case PB_Gpio_GpioInputPull_UP:
return GpioPullUp;
case PB_Gpio_GpioInputPull_DOWN:
return GpioPullDown;
case PB_Gpio_GpioInputPull_NO:
return GpioPullNo;
}
__builtin_unreachable();
}
static void rpc_system_gpio_set_pin_mode(const PB_Main* request, void* context) {
furi_assert(request);
furi_assert(context);
furi_assert(request->which_content == PB_Main_gpio_set_pin_mode_tag);
RpcSession* session = context;
furi_assert(session);
PB_Gpio_SetPinMode cmd = request->content.gpio_set_pin_mode;
const GpioPin* pin = rpc_pin_to_hal_pin(cmd.pin);
GpioMode mode = rpc_mode_to_hal_mode(cmd.mode);
furi_hal_gpio_init_simple(pin, mode);
if(mode == GpioModeOutputPushPull) {
furi_hal_gpio_write(pin, false);
}
rpc_send_and_release_empty(session, request->command_id, PB_CommandStatus_OK);
}
static void rpc_system_gpio_write_pin(const PB_Main* request, void* context) {
furi_assert(request);
furi_assert(context);
furi_assert(request->which_content == PB_Main_gpio_write_pin_tag);
RpcSession* session = context;
furi_assert(session);
PB_Gpio_WritePin cmd = request->content.gpio_write_pin;
const GpioPin* pin = rpc_pin_to_hal_pin(cmd.pin);
uint8_t value = !!(cmd.value);
PB_Main* response = malloc(sizeof(PB_Main));
response->command_id = request->command_id;
response->has_next = false;
if(LL_GPIO_MODE_OUTPUT != LL_GPIO_GetPinMode(pin->port, pin->pin)) {
response->command_status = PB_CommandStatus_ERROR_GPIO_MODE_INCORRECT;
} else {
response->command_status = PB_CommandStatus_OK;
furi_hal_gpio_write(pin, value);
}
rpc_send_and_release(session, response);
free(response);
}
static void rpc_system_gpio_read_pin(const PB_Main* request, void* context) {
furi_assert(request);
furi_assert(context);
furi_assert(request->which_content == PB_Main_gpio_read_pin_tag);
RpcSession* session = context;
furi_assert(session);
PB_Gpio_ReadPin cmd = request->content.gpio_read_pin;
const GpioPin* pin = rpc_pin_to_hal_pin(cmd.pin);
PB_Main* response = malloc(sizeof(PB_Main));
response->command_id = request->command_id;
response->has_next = false;
if(LL_GPIO_MODE_INPUT != LL_GPIO_GetPinMode(pin->port, pin->pin)) {
response->command_status = PB_CommandStatus_ERROR_GPIO_MODE_INCORRECT;
} else {
response->command_status = PB_CommandStatus_OK;
response->which_content = PB_Main_gpio_read_pin_response_tag;
response->content.gpio_read_pin_response.value = !!furi_hal_gpio_read(pin);
}
rpc_send_and_release(session, response);
free(response);
}
void rpc_system_gpio_get_pin_mode(const PB_Main* request, void* context) {
furi_assert(request);
furi_assert(context);
furi_assert(request->which_content == PB_Main_gpio_get_pin_mode_tag);
RpcSession* session = context;
furi_assert(session);
PB_Gpio_GetPinMode cmd = request->content.gpio_get_pin_mode;
const GpioPin* pin = rpc_pin_to_hal_pin(cmd.pin);
PB_Main* response = malloc(sizeof(PB_Main));
response->command_id = request->command_id;
response->has_next = false;
uint32_t raw_pin_mode = LL_GPIO_GetPinMode(pin->port, pin->pin);
PB_Gpio_GpioPinMode pin_mode;
if(LL_GPIO_MODE_INPUT == raw_pin_mode) {
pin_mode = PB_Gpio_GpioPinMode_INPUT;
response->command_status = PB_CommandStatus_OK;
} else if(LL_GPIO_MODE_OUTPUT == raw_pin_mode) {
pin_mode = PB_Gpio_GpioPinMode_OUTPUT;
response->command_status = PB_CommandStatus_OK;
} else {
pin_mode = PB_Gpio_GpioPinMode_INPUT;
response->command_status = PB_CommandStatus_ERROR_GPIO_UNKNOWN_PIN_MODE;
}
response->which_content = PB_Main_gpio_get_pin_mode_response_tag;
response->content.gpio_get_pin_mode_response.mode = pin_mode;
rpc_send_and_release(session, response);
free(response);
}
void rpc_system_gpio_set_input_pull(const PB_Main* request, void* context) {
furi_assert(request);
furi_assert(context);
furi_assert(request->which_content == PB_Main_gpio_set_input_pull_tag);
RpcSession* session = context;
furi_assert(session);
PB_Gpio_SetInputPull cmd = request->content.gpio_set_input_pull;
const GpioPin* pin = rpc_pin_to_hal_pin(cmd.pin);
const GpioPull pull_mode = rpc_pull_mode_to_hall_pull_mode(cmd.pull_mode);
PB_Main* response = malloc(sizeof(PB_Main));
response->command_id = request->command_id;
response->has_next = false;
PB_CommandStatus status;
if(LL_GPIO_MODE_INPUT != LL_GPIO_GetPinMode(pin->port, pin->pin)) {
status = PB_CommandStatus_ERROR_GPIO_MODE_INCORRECT;
} else {
status = PB_CommandStatus_OK;
furi_hal_gpio_init(pin, GpioModeInput, pull_mode, GpioSpeedLow);
}
rpc_send_and_release_empty(session, request->command_id, status);
free(response);
}
void* rpc_system_gpio_alloc(RpcSession* session) {
furi_assert(session);
RpcHandler rpc_handler = {
.message_handler = NULL,
.decode_submessage = NULL,
.context = session,
};
rpc_handler.message_handler = rpc_system_gpio_set_pin_mode;
rpc_add_handler(session, PB_Main_gpio_set_pin_mode_tag, &rpc_handler);
rpc_handler.message_handler = rpc_system_gpio_write_pin;
rpc_add_handler(session, PB_Main_gpio_write_pin_tag, &rpc_handler);
rpc_handler.message_handler = rpc_system_gpio_read_pin;
rpc_add_handler(session, PB_Main_gpio_read_pin_tag, &rpc_handler);
rpc_handler.message_handler = rpc_system_gpio_get_pin_mode;
rpc_add_handler(session, PB_Main_gpio_get_pin_mode_tag, &rpc_handler);
rpc_handler.message_handler = rpc_system_gpio_set_input_pull;
rpc_add_handler(session, PB_Main_gpio_set_input_pull_tag, &rpc_handler);
return NULL;
}

3
applications/rpc/rpc_i.h
View file

@ -29,8 +29,11 @@ void* rpc_system_system_alloc(RpcSession* session);
void* rpc_system_storage_alloc(RpcSession* session);
void rpc_system_storage_free(void* ctx);
void* rpc_system_app_alloc(RpcSession* session);
void rpc_system_app_free(void* ctx);
void* rpc_system_gui_alloc(RpcSession* session);
void rpc_system_gui_free(void* ctx);
void* rpc_system_gpio_alloc(RpcSession* session);
void rpc_system_gpio_free(void* ctx);
void rpc_print_message(const PB_Main* message);
void rpc_cli_command_start_session(Cli* cli, string_t args, void* context);

4
applications/rpc/rpc_system.c
View file

@ -277,10 +277,6 @@ static void rpc_system_system_update_request_process(const PB_Main* request, voi
UpdatePrepareResult update_prepare_result =
update_operation_prepare(request->content.system_update_request.update_manifest);
/* RPC enum does not have such entry; setting to closest one */
if(update_prepare_result == UpdatePrepareResultOutdatedManifestVersion) {
update_prepare_result = UpdatePrepareResultManifestInvalid;
}
PB_Main* response = malloc(sizeof(PB_Main));
response->command_id = request->command_id;

43
applications/snake_game/snake_game.c
View file

@ -31,6 +31,8 @@ typedef enum {
GameStateGameOver,
} GameState;
// Note: do not change without purpose. Current values are used in smart
// orthogonality calculation in `snake_game_get_turn_snake`.
typedef enum {
DirectionUp,
DirectionRight,
@ -203,44 +205,9 @@ static bool
}
static Direction snake_game_get_turn_snake(SnakeState const* const snake_state) {
switch(snake_state->currentMovement) {
case DirectionUp:
switch(snake_state->nextMovement) {
case DirectionRight:
return DirectionRight;
case DirectionLeft:
return DirectionLeft;
default:
return snake_state->currentMovement;
}
case DirectionRight:
switch(snake_state->nextMovement) {
case DirectionUp:
return DirectionUp;
case DirectionDown:
return DirectionDown;
default:
return snake_state->currentMovement;
}
case DirectionDown:
switch(snake_state->nextMovement) {
case DirectionRight:
return DirectionRight;
case DirectionLeft:
return DirectionLeft;
default:
return snake_state->currentMovement;
}
default: // case DirectionLeft:
switch(snake_state->nextMovement) {
case DirectionUp:
return DirectionUp;
case DirectionDown:
return DirectionDown;
default:
return snake_state->currentMovement;
}
}
// Sum of two `Direction` lies between 0 and 6, odd values indicate orthogonality.
bool is_orthogonal = (snake_state->currentMovement + snake_state->nextMovement) % 2 == 1;
return is_orthogonal ? snake_state->nextMovement : snake_state->currentMovement;
}
static Point snake_game_get_next_step(SnakeState const* const snake_state) {

8
applications/storage/storages/storage_int.c
View file

@ -655,11 +655,13 @@ static FS_Error storage_int_common_fs_info(
lfs_t* lfs = lfs_get_from_storage(storage);
LFSData* lfs_data = lfs_data_get_from_storage(storage);
*total_space = lfs_data->config.block_size * lfs_data->config.block_count;
if(total_space) {
*total_space = lfs_data->config.block_size * lfs_data->config.block_count;
}
lfs_ssize_t result = lfs_fs_size(lfs);
if(result >= 0) {
*free_space = *total_space - (result * lfs_data->config.block_size);
if(free_space && (result >= 0)) {
*free_space = (lfs_data->config.block_count - result) * lfs_data->config.block_size;
}
return storage_int_parse_error(result);

1
applications/subghz/scenes/subghz_scene_config.h
View file

@ -28,3 +28,4 @@ ADD_SCENE(subghz, read_raw, ReadRAW)
ADD_SCENE(subghz, more_raw, MoreRAW)
ADD_SCENE(subghz, delete_raw, DeleteRAW)
ADD_SCENE(subghz, need_saving, NeedSaving)
ADD_SCENE(subghz, rpc, Rpc)

34
applications/subghz/scenes/subghz_scene_rpc.c Normal file
View file

@ -0,0 +1,34 @@
#include "../subghz_i.h"
void subghz_scene_rpc_on_enter(void* context) {
SubGhz* subghz = context;
Widget* widget = subghz->widget;
widget_add_text_box_element(
widget, 0, 0, 128, 28, AlignCenter, AlignCenter, "RPC mode", false);
notification_message(subghz->notifications, &sequence_display_backlight_on);
view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdWidget);
}
bool subghz_scene_rpc_on_event(void* context, SceneManagerEvent event) {
SubGhz* subghz = context;
bool consumed = false;
if(event.type == SceneManagerEventTypeCustom) {
consumed = true;
if(event.event == SubGhzCustomEventSceneExit) {
view_dispatcher_stop(subghz->view_dispatcher);
}
}
return consumed;
}
void subghz_scene_rpc_on_exit(void* context) {
SubGhz* subghz = context;
//subghz_rpc_exit_callback(subghz);
widget_reset(subghz->widget);
}

60
applications/subghz/subghz.c
View file

@ -23,6 +23,54 @@ void subghz_tick_event_callback(void* context) {
scene_manager_handle_tick_event(subghz->scene_manager);
}
static bool subghz_rpc_command_callback(RpcAppSystemEvent event, const char* arg, void* context) {
furi_assert(context);
SubGhz* subghz = context;
if(!subghz->rpc_ctx) {
return false;
}
bool result = false;
if(event == RpcAppEventSessionClose) {
rpc_system_app_set_callback(subghz->rpc_ctx, NULL, NULL);
subghz->rpc_ctx = NULL;
view_dispatcher_send_custom_event(subghz->view_dispatcher, SubGhzCustomEventSceneExit);
if(subghz->txrx->txrx_state == SubGhzTxRxStateTx) {
subghz_tx_stop(subghz);
subghz_sleep(subghz);
}
result = true;
} else if(event == RpcAppEventAppExit) {
view_dispatcher_send_custom_event(subghz->view_dispatcher, SubGhzCustomEventSceneExit);
if(subghz->txrx->txrx_state == SubGhzTxRxStateTx) {
subghz_tx_stop(subghz);
subghz_sleep(subghz);
}
result = true;
} else if(event == RpcAppEventLoadFile) {
if(arg) {
if(subghz_key_load(subghz, arg, false)) {
string_set_str(subghz->file_path, arg);
result = true;
}
}
} else if(event == RpcAppEventButtonPress) {
if(subghz->txrx->txrx_state == SubGhzTxRxStateSleep) {
result = subghz_tx_start(subghz, subghz->txrx->fff_data);
}
} else if(event == RpcAppEventButtonRelease) {
if(subghz->txrx->txrx_state == SubGhzTxRxStateTx) {
subghz_tx_stop(subghz);
subghz_sleep(subghz);
result = true;
}
}
return result;
}
SubGhz* subghz_alloc() {
SubGhz* subghz = malloc(sizeof(SubGhz));
@ -174,6 +222,11 @@ SubGhz* subghz_alloc() {
void subghz_free(SubGhz* subghz) {
furi_assert(subghz);
if(subghz->rpc_ctx) {
rpc_system_app_set_callback(subghz->rpc_ctx, NULL, NULL);
subghz->rpc_ctx = NULL;
}
// Packet Test
view_dispatcher_remove_view(subghz->view_dispatcher, SubGhzViewIdTestPacket);
subghz_test_packet_free(subghz->subghz_test_packet);
@ -276,7 +329,12 @@ int32_t subghz_app(void* p) {
subghz->txrx->environment, "/ext/subghz/assets/keeloq_mfcodes_user");
// Check argument and run corresponding scene
if(p) {
if(subghz_key_load(subghz, p)) {
uint32_t rpc_ctx = 0;
if(sscanf(p, "RPC %lX", &rpc_ctx) == 1) {
subghz->rpc_ctx = (void*)rpc_ctx;
rpc_system_app_set_callback(subghz->rpc_ctx, subghz_rpc_command_callback, subghz);
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneRpc);
} else if(subghz_key_load(subghz, p, true)) {
string_set_str(subghz->file_path, p);
if((!strcmp(subghz->txrx->decoder_result->protocol->name, "RAW"))) {

12
applications/subghz/subghz_i.c
View file

@ -218,7 +218,7 @@ void subghz_dialog_message_show_only_rx(SubGhz* subghz) {
dialog_message_free(message);
}
bool subghz_key_load(SubGhz* subghz, const char* file_path) {
bool subghz_key_load(SubGhz* subghz, const char* file_path, bool show_dialog) {
furi_assert(subghz);
furi_assert(file_path);
@ -308,11 +308,15 @@ bool subghz_key_load(SubGhz* subghz, const char* file_path) {
switch(load_key_state) {
case SubGhzLoadKeyStateParseErr:
dialog_message_show_storage_error(subghz->dialogs, "Cannot parse\nfile");
if(show_dialog) {
dialog_message_show_storage_error(subghz->dialogs, "Cannot parse\nfile");
}
return false;
case SubGhzLoadKeyStateOnlyRx:
subghz_dialog_message_show_only_rx(subghz);
if(show_dialog) {
subghz_dialog_message_show_only_rx(subghz);
}
return false;
case SubGhzLoadKeyStateOK:
@ -427,7 +431,7 @@ bool subghz_load_protocol_from_file(SubGhz* subghz) {
true);
if(res) {
res = subghz_key_load(subghz, string_get_cstr(subghz->file_path));
res = subghz_key_load(subghz, string_get_cstr(subghz->file_path), true);
}
string_clear(file_path);

6
applications/subghz/subghz_i.h
View file

@ -37,6 +37,8 @@
#include <gui/modules/variable_item_list.h>
#include <lib/toolbox/path.h>
#include "rpc/rpc_app.h"
#define SUBGHZ_MAX_LEN_NAME 64
typedef struct {
@ -100,6 +102,8 @@ struct SubGhz {
string_t error_str;
SubGhzSetting* setting;
SubGhzLock lock;
void* rpc_ctx;
};
bool subghz_set_preset(SubGhz* subghz, const char* preset);
@ -111,7 +115,7 @@ void subghz_sleep(SubGhz* subghz);
bool subghz_tx_start(SubGhz* subghz, FlipperFormat* flipper_format);
void subghz_tx_stop(SubGhz* subghz);
void subghz_dialog_message_show_only_rx(SubGhz* subghz);
bool subghz_key_load(SubGhz* subghz, const char* file_path);
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);
bool subghz_save_protocol_to_file(
SubGhz* subghz,

15
applications/updater/util/update_task.c
View file

@ -44,17 +44,17 @@ static const UpdateTaskStageGroupMap update_task_stage_progress[] = {
[UpdateTaskStageReadManifest] = STAGE_DEF(UpdateTaskStageGroupPreUpdate, 5),
[UpdateTaskStageLfsBackup] = STAGE_DEF(UpdateTaskStageGroupPreUpdate, 15),
[UpdateTaskStageRadioImageValidate] = STAGE_DEF(UpdateTaskStageGroupRadio, 10),
[UpdateTaskStageRadioErase] = STAGE_DEF(UpdateTaskStageGroupRadio, 50),
[UpdateTaskStageRadioWrite] = STAGE_DEF(UpdateTaskStageGroupRadio, 90),
[UpdateTaskStageRadioInstall] = STAGE_DEF(UpdateTaskStageGroupRadio, 15),
[UpdateTaskStageRadioBusy] = STAGE_DEF(UpdateTaskStageGroupRadio, 60),
[UpdateTaskStageRadioImageValidate] = STAGE_DEF(UpdateTaskStageGroupRadio, 15),
[UpdateTaskStageRadioErase] = STAGE_DEF(UpdateTaskStageGroupRadio, 60),
[UpdateTaskStageRadioWrite] = STAGE_DEF(UpdateTaskStageGroupRadio, 80),
[UpdateTaskStageRadioInstall] = STAGE_DEF(UpdateTaskStageGroupRadio, 60),
[UpdateTaskStageRadioBusy] = STAGE_DEF(UpdateTaskStageGroupRadio, 80),
[UpdateTaskStageOBValidation] = STAGE_DEF(UpdateTaskStageGroupOptionBytes, 10),
[UpdateTaskStageValidateDFUImage] = STAGE_DEF(UpdateTaskStageGroupFirmware, 100),
[UpdateTaskStageValidateDFUImage] = STAGE_DEF(UpdateTaskStageGroupFirmware, 50),
[UpdateTaskStageFlashWrite] = STAGE_DEF(UpdateTaskStageGroupFirmware, 200),
[UpdateTaskStageFlashValidate] = STAGE_DEF(UpdateTaskStageGroupFirmware, 50),
[UpdateTaskStageFlashValidate] = STAGE_DEF(UpdateTaskStageGroupFirmware, 30),
[UpdateTaskStageLfsRestore] = STAGE_DEF(UpdateTaskStageGroupPostUpdate, 30),
@ -214,6 +214,7 @@ UpdateTask* update_task_alloc() {
update_task->storage = furi_record_open("storage");
update_task->file = storage_file_alloc(update_task->storage);
update_task->status_change_cb = NULL;
update_task->boot_mode = furi_hal_rtc_get_boot_mode();
string_init(update_task->update_path);
FuriThread* thread = update_task->thread = furi_thread_alloc();

2
applications/updater/util/update_task_i.h
View file

@ -1,6 +1,7 @@
#pragma once
#include <storage/storage.h>
#include <furi_hal.h>
#define UPDATE_TASK_NOERR 0
#define UPDATE_TASK_FAILED -1
@ -14,6 +15,7 @@ typedef struct UpdateTask {
File* file;
updateProgressCb status_change_cb;
void* status_change_cb_state;
FuriHalRtcBootMode boot_mode;
} UpdateTask;
void update_task_set_progress(UpdateTask* update_task, UpdateTaskStage stage, uint8_t progress);

35
applications/updater/util/update_task_worker_backup.c
View file

@ -67,7 +67,6 @@ static bool update_task_post_update(UpdateTask* update_task) {
string_get_cstr(update_task->update_path), LFS_BACKUP_DEFAULT_FILENAME, file_path);
update_task_set_progress(update_task, UpdateTaskStageLfsRestore, 0);
update_operation_disarm();
CHECK_RESULT(lfs_backup_unpack(update_task->storage, string_get_cstr(file_path)));
@ -117,28 +116,32 @@ static bool update_task_post_update(UpdateTask* update_task) {
int32_t update_task_worker_backup_restore(void* context) {
furi_assert(context);
UpdateTask* update_task = context;
bool success = false;
FuriHalRtcBootMode boot_mode = furi_hal_rtc_get_boot_mode();
FuriHalRtcBootMode boot_mode = update_task->boot_mode;
if((boot_mode != FuriHalRtcBootModePreUpdate) && (boot_mode != FuriHalRtcBootModePostUpdate)) {
/* no idea how we got here. Clear to normal boot */
update_operation_disarm();
/* no idea how we got here. Do nothing */
return UPDATE_TASK_NOERR;
}
if(!update_task_parse_manifest(update_task)) {
return UPDATE_TASK_FAILED;
}
bool success = false;
do {
if(!update_task_parse_manifest(update_task)) {
break;
}
/* Waiting for BT service to 'start', so we don't race for boot mode flag */
furi_record_open("bt");
furi_record_close("bt");
/* Waiting for BT service to 'start', so we don't race for boot mode flag */
furi_record_open("bt");
furi_record_close("bt");
if(boot_mode == FuriHalRtcBootModePreUpdate) {
success = update_task_pre_update(update_task);
} else if(boot_mode == FuriHalRtcBootModePostUpdate) {
success = update_task_post_update(update_task);
}
if(boot_mode == FuriHalRtcBootModePreUpdate) {
success = update_task_pre_update(update_task);
} else if(boot_mode == FuriHalRtcBootModePostUpdate) {
success = update_task_post_update(update_task);
if(success) {
update_operation_disarm();
}
}
} while(false);
if(!success) {
update_task_set_progress(update_task, UpdateTaskStageError, 0);

2
applications/updater/util/update_task_worker_flasher.c
View file

@ -340,6 +340,8 @@ int32_t update_task_worker_flash_writer(void* context) {
}
furi_hal_rtc_set_boot_mode(FuriHalRtcBootModePostUpdate);
// Format LFS before restoring backup on next boot
furi_hal_rtc_set_flag(FuriHalRtcFlagFactoryReset);
update_task_set_progress(update_task, UpdateTaskStageCompleted, 100);
success = true;

2
assets/protobuf

@ -1 +1 @@
Subproject commit ffa62429f3c678537e0e883a3a8c3ae5f1398ed4
Subproject commit d9e343661dd36cfab792b78be1dea4e5950cb4dd

8
documentation/fbt.md
View file

@ -10,7 +10,10 @@ Make sure that `gcc-arm-none-eabi` toolchain & OpenOCD executables are in system
## NB
FBT constructs all referenced environments & their targets' dependency trees on startup. So, to keep startup time as low as possible, we're hiding construction of certain targets behind command-line options.
* `fbt` constructs all referenced environments & their targets' dependency trees on startup. So, to keep startup time as low as possible, we're hiding construction of certain targets behind command-line options.
* `fbt` always performs `git submodule update --init` on start, unless you set `FBT_NO_SYNC=1` in environment:
* On Windows, that's `set "FBT_NO_SYNC=1"` in the shell you're running `fbt` from
* On \*nix, it's `$ FBT_NO_SYNC=1 ./fbt ...`
## Invoking FBT
@ -34,7 +37,9 @@ FBT keeps track of internal dependencies, so you only need to build the highest-
- `debug` - build and flash firmware, then attach with gdb with firmware's .elf loaded
- `debug_updater` - attach gdb with updater's .elf loaded. _Requires `--with-updater` option_
- `debug_other` - attach gdb without loading any .elf. Allows to manually add external elf files with `add-symbol-file` in gdb.
- `blackmagic` - debug firmware with Blackmagic probe (WiFi dev board)
- `openocd` - just start OpenOCD
- `get_blackmagic` - output blackmagic address in gdb remote format. Useful for IDE integration
### Firmware targets
@ -43,6 +48,7 @@ FBT keeps track of internal dependencies, so you only need to build the highest-
- Check out `--extra-ext-apps` for force adding extra apps to external build
- `firmware_snake_game_list`, etc - generate source + assembler listing for app's .elf
- `flash`, `firmware_flash` - flash current version to attached device with OpenOCD over ST-Link
- `flash_blackmagic` - flash current version to attached device with Blackmagic probe
- `firmware_cdb` - generate compilation database
- `firmware_all`, `updater_all` - build basic set of binaries
- `firmware_list`, `updater_list` - generate source + assembler listing

14
fbt
View file

@ -5,13 +5,13 @@ set -e
SCRIPTDIR="$( dirname -- "$0"; )";
SCONS_EP=${SCRIPTDIR}/lib/scons/scripts/scons.py
if [[ -d .git ]]; then
echo Updating git submodules
git submodule update --init
else # Not in a git repo
echo Not in a git repo, please clone with git clone --recursive
# Return error code 1 to indicate failure
exit 1
if [[ -z "${FBT_NO_SYNC:-}" ]] ; then
if [[ -d .git ]]; then
git submodule update --init
else
echo Not in a git repo, please clone with git clone --recursive
exit 1
fi
fi
SCONS_DEFAULT_FLAGS="-Q --warn=target-not-built"

17
fbt.cmd
View file

@ -1,12 +1,19 @@
@echo off
set SCONS_EP=%~dp0\lib\scons\scripts\scons.py
if [%FBT_NO_SYNC%] == [] (
if exist ".git" (
git submodule update --init
) else (
echo Not in a git repo, please clone with git clone --recursive
exit /b 1
)
)
set "flipper_toolchain_version=2"
set "toolchainRoot=%~dp0toolchain\i686-windows"
set "SCONS_DEFAULT_FLAGS=-Q --warn=target-not-built"
if not exist "%~dp0.git" (
echo ".git" directory not found, please clone repo via "git clone --recursive"
exit /B 1
)
git submodule update --init
if not exist "%toolchainRoot%" (
powershell -ExecutionPolicy Bypass -File %~dp0scripts\toolchain\windows-toolchain-download.ps1 "%flipper_toolchain_version%"
)

16
fbt_options.py
View file

@ -41,10 +41,24 @@ COPRO_STACK_BIN_DIR = posixpath.join(
# Supported toolchain versions
FBT_TOOLCHAIN_VERSIONS = (" 10.3.",)
OPENOCD_OPTS = '-f interface/stlink.cfg -c "transport select hla_swd" -f debug/stm32wbx.cfg -c "stm32wbx.cpu configure -rtos auto" -c "init"'
OPENOCD_OPTS = [
"-f",
"interface/stlink.cfg",
"-c",
"transport select hla_swd",
"-f",
"debug/stm32wbx.cfg",
"-c",
"stm32wbx.cpu configure -rtos auto",
"-c",
"init",
]
SVD_FILE = "debug/STM32WB55_CM4.svd"
# Look for blackmagic probe on serial ports
BLACKMAGIC = "auto"
FIRMWARE_APPS = {
"default": [
"crypto_start",

18
firmware.scons
View file

@ -6,7 +6,7 @@ from fbt.util import link_dir
# Building initial C environment for libs
env = ENV.Clone(
tools=["compilation_db", "fwbin", "openocd", "fbt_apps"],
tools=["compilation_db", "fwbin", "fbt_apps"],
COMPILATIONDB_USE_ABSPATH=True,
BUILD_DIR=fw_build_meta["build_dir"],
IS_BASE_FIRMWARE=fw_build_meta["type"] == "firmware",
@ -139,6 +139,8 @@ apps_c = fwenv.ApplicationsC(
"applications/applications.c",
Value(fwenv["APPS"]),
)
# Adding dependency on manifest files so apps.c is rebuilt when any manifest is changed
fwenv.Depends(apps_c, fwenv.GlobRecursive("*.fam", "applications"))
sources = [apps_c]
# Gather sources only from app folders from current configuration
@ -235,7 +237,7 @@ AddPostAction(fwelf, Action("@$SIZECOM"))
AddPostAction(fwelf, Action(link_latest_dir, None))
link_dir_command = fwenv["LINK_DIR_CMD"] = fwenv.PhonyTarget(
"${FIRMWARE_BUILD_CFG}" + "_latest",
fwenv.subst("${FIRMWARE_BUILD_CFG}_latest"),
Action(lambda target, source, env: link_elf_dir_as_latest(env, source[0]), None),
source=fwelf,
)
@ -249,18 +251,6 @@ Alias(fwenv["FIRMWARE_BUILD_CFG"] + "_dfu", fwdfu)
fwdump = fwenv.ObjDump("${FIRMWARE_BUILD_CFG}")
Alias(fwenv["FIRMWARE_BUILD_CFG"] + "_list", fwdump)
# Additional FW-related pseudotargets
flash = fwenv["FW_FLASH"] = fwenv.OpenOCDFlash(
"#build/oocd-${FIRMWARE_BUILD_CFG}-flash.flag",
"${FIRMWARE_BUILD_CFG}",
OPENOCD_COMMAND='-c "program ${SOURCE.posix} reset exit ${IMAGE_BASE_ADDRESS}"',
)
if fwenv["FORCE"]:
fwenv.AlwaysBuild(flash)
fwenv.Alias(fwenv["FIRMWARE_BUILD_CFG"] + "_flash", flash)
if fwenv["IS_BASE_FIRMWARE"]:
fwenv.Alias("flash", flash)
# Compile DB generation
fwcdb = fwenv["FW_CDB"] = fwenv.CompilationDatabase("compile_commands.json")

9
firmware/targets/f7/furi_hal/furi_hal_power.c
View file

@ -1,5 +1,6 @@
#include <furi_hal_power.h>
#include <furi_hal_clock.h>
#include <furi_hal_delay.h>
#include <furi_hal_bt.h>
#include <furi_hal_resources.h>
#include <furi_hal_uart.h>
@ -299,6 +300,10 @@ void furi_hal_power_shutdown() {
}
void furi_hal_power_off() {
// Crutch: shutting down with ext 3V3 off is causing LSE to stop
furi_hal_power_enable_external_3_3v();
furi_hal_delay_us(1000);
// Send poweroff to charger
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
bq25896_poweroff(&furi_hal_i2c_handle_power);
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
@ -482,11 +487,11 @@ void furi_hal_power_dump_state() {
}
void furi_hal_power_enable_external_3_3v() {
LL_GPIO_SetOutputPin(PERIPH_POWER_GPIO_Port, PERIPH_POWER_Pin);
furi_hal_gpio_write(&periph_power, 1);
}
void furi_hal_power_disable_external_3_3v() {
LL_GPIO_ResetOutputPin(PERIPH_POWER_GPIO_Port, PERIPH_POWER_Pin);
furi_hal_gpio_write(&periph_power, 0);
}
void furi_hal_power_suppress_charge_enter() {

8
firmware/targets/f7/furi_hal/furi_hal_resources.c
View file

@ -58,7 +58,7 @@ const GpioPin gpio_i2c_power_scl = {.port = GPIOA, .pin = LL_GPIO_PIN_9};
const GpioPin gpio_speaker = {.port = GPIOB, .pin = LL_GPIO_PIN_8};
const GpioPin periph_power = {.port = PERIPH_POWER_GPIO_Port, .pin = PERIPH_POWER_Pin};
const GpioPin periph_power = {.port = GPIOA, .pin = LL_GPIO_PIN_3};
const GpioPin gpio_usb_dm = {.port = GPIOA, .pin = LL_GPIO_PIN_11};
const GpioPin gpio_usb_dp = {.port = GPIOA, .pin = LL_GPIO_PIN_12};
@ -77,6 +77,10 @@ const size_t input_pins_count = sizeof(input_pins) / sizeof(InputPin);
void furi_hal_resources_init_early() {
furi_hal_gpio_init(&gpio_button_left, GpioModeInput, GpioPullUp, GpioSpeedLow);
// SD Card stepdown control
furi_hal_gpio_write(&periph_power, 1);
furi_hal_gpio_init(&periph_power, GpioModeOutputOpenDrain, GpioPullNo, GpioSpeedLow);
// Display pins
furi_hal_gpio_write(&gpio_display_rst_n, 1);
furi_hal_gpio_init_simple(&gpio_display_rst_n, GpioModeOutputPushPull);
@ -142,8 +146,6 @@ void furi_hal_resources_init() {
furi_hal_gpio_init(&gpio_rf_sw_0, GpioModeOutputPushPull, GpioPullNo, GpioSpeedLow);
furi_hal_gpio_init(&periph_power, GpioModeOutputOpenDrain, GpioPullNo, GpioSpeedLow);
NVIC_SetPriority(EXTI0_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 5, 0));
NVIC_EnableIRQ(EXTI0_IRQn);

3
firmware/targets/f7/furi_hal/furi_hal_resources.h
View file

@ -147,9 +147,6 @@ extern const GpioPin gpio_usb_dp;
#define PC3_GPIO_Port GPIOC
#define PC3_Pin LL_GPIO_PIN_3
#define PERIPH_POWER_GPIO_Port GPIOA
#define PERIPH_POWER_Pin LL_GPIO_PIN_3
#define QUARTZ_32MHZ_IN_GPIO_Port GPIOC
#define QUARTZ_32MHZ_IN_Pin LL_GPIO_PIN_14
#define QUARTZ_32MHZ_OUT_GPIO_Port GPIOC

108
firmware/targets/f7/furi_hal/furi_hal_rtc.c
View file

@ -12,7 +12,9 @@
#define TAG "FuriHalRtc"
#define RTC_CLOCK_IS_READY() (LL_RCC_LSE_IsReady() && LL_RCC_LSI1_IsReady())
#define FURI_HAL_RTC_LSE_STARTUP_TIME 300
#define FURI_HAL_RTC_CLOCK_IS_READY() (LL_RCC_LSE_IsReady() && LL_RCC_LSI1_IsReady())
#define FURI_HAL_RTC_HEADER_MAGIC 0x10F1
#define FURI_HAL_RTC_HEADER_VERSION 0
@ -47,33 +49,83 @@ static const uint8_t furi_hal_rtc_days_per_month[][FURI_HAL_RTC_MONTHS_COUNT] =
static const uint16_t furi_hal_rtc_days_per_year[] = {365, 366};
void furi_hal_rtc_init_early() {
// LSE and RTC
static void furi_hal_rtc_reset() {
LL_RCC_ForceBackupDomainReset();
LL_RCC_ReleaseBackupDomainReset();
}
static bool furi_hal_rtc_start_clock_and_switch() {
// Clock operation require access to Backup Domain
LL_PWR_EnableBkUpAccess();
if(!RTC_CLOCK_IS_READY()) {
LL_RCC_LSI1_Enable();
// Try to start LSE normal way
LL_RCC_LSE_SetDriveCapability(LL_RCC_LSEDRIVE_HIGH);
LL_RCC_LSE_Enable();
uint32_t c = 0;
while(!RTC_CLOCK_IS_READY() && c < 200) {
LL_mDelay(10);
c++;
}
// Plan B: reset backup domain
if(!RTC_CLOCK_IS_READY()) {
furi_hal_light_sequence("rgb R.r.R.r.R");
LL_RCC_ForceBackupDomainReset();
LL_RCC_ReleaseBackupDomainReset();
NVIC_SystemReset();
}
// Set RTC domain clock to LSE
LL_RCC_SetRTCClockSource(LL_RCC_RTC_CLKSOURCE_LSE);
// Enable LSI and LSE
LL_RCC_LSI1_Enable();
LL_RCC_LSE_SetDriveCapability(LL_RCC_LSEDRIVE_HIGH);
LL_RCC_LSE_Enable();
// Wait for LSI and LSE startup
uint32_t c = 0;
while(!FURI_HAL_RTC_CLOCK_IS_READY() && c < FURI_HAL_RTC_LSE_STARTUP_TIME) {
LL_mDelay(1);
c++;
}
// Enable clocking
LL_RCC_EnableRTC();
if(FURI_HAL_RTC_CLOCK_IS_READY()) {
LL_RCC_SetRTCClockSource(LL_RCC_RTC_CLKSOURCE_LSE);
LL_RCC_EnableRTC();
return LL_RCC_GetRTCClockSource() == LL_RCC_RTC_CLKSOURCE_LSE;
} else {
return false;
}
}
static void furi_hal_rtc_recover() {
FuriHalRtcDateTime datetime = {0};
// Handle fixable LSE failure
if(LL_RCC_LSE_IsCSSDetected()) {
furi_hal_light_sequence("rgb B");
// Shutdown LSE and LSECSS
LL_RCC_LSE_DisableCSS();
LL_RCC_LSE_Disable();
} else {
furi_hal_light_sequence("rgb R");
}
// Temporary switch to LSI
LL_RCC_SetRTCClockSource(LL_RCC_RTC_CLKSOURCE_LSI);
if(LL_RCC_GetRTCClockSource() == LL_RCC_RTC_CLKSOURCE_LSI) {
// Get datetime before RTC Domain reset
furi_hal_rtc_get_datetime(&datetime);
}
// Reset RTC Domain
furi_hal_rtc_reset();
// Start Clock
if(!furi_hal_rtc_start_clock_and_switch()) {
// Plan C: reset RTC and restart
furi_hal_light_sequence("rgb R.r.R.r.R.r");
furi_hal_rtc_reset();
NVIC_SystemReset();
}
// Set date if it valid
if(datetime.year != 0) {
furi_hal_rtc_set_datetime(&datetime);
}
}
void furi_hal_rtc_init_early() {
// Enable RTCAPB clock
LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_RTCAPB);
// Prepare clock
if(!furi_hal_rtc_start_clock_and_switch()) {
// Plan B: try to recover
furi_hal_rtc_recover();
}
// Verify header register
uint32_t data_reg = furi_hal_rtc_get_register(FuriHalRtcRegisterHeader);
FuriHalRtcHeader* data = (FuriHalRtcHeader*)&data_reg;
@ -98,14 +150,6 @@ void furi_hal_rtc_deinit_early() {
}
void furi_hal_rtc_init() {
if(LL_RCC_GetRTCClockSource() != LL_RCC_RTC_CLKSOURCE_LSE) {
LL_RCC_ForceBackupDomainReset();
LL_RCC_ReleaseBackupDomainReset();
LL_RCC_SetRTCClockSource(LL_RCC_RTC_CLKSOURCE_LSE);
}
LL_RCC_EnableRTC();
LL_RTC_InitTypeDef RTC_InitStruct = {0};
RTC_InitStruct.HourFormat = LL_RTC_HOURFORMAT_24HOUR;
RTC_InitStruct.AsynchPrescaler = 127;

12
lib/update_util/update_operation.c
View file

@ -12,6 +12,8 @@
#define UPDATE_ROOT_DIR "/ext" UPDATE_DIR_DEFAULT_REL_PATH
#define UPDATE_PREFIX "/ext" UPDATE_DIR_DEFAULT_REL_PATH "/"
#define UPDATE_SUFFIX "/" UPDATE_MANIFEST_DEFAULT_NAME
/* Need at least 4 free LFS pages before update */
#define UPDATE_MIN_INT_FREE_SPACE 4 * 4 * 1024
static const char* update_prepare_result_descr[] = {
[UpdatePrepareResultOK] = "OK",
@ -22,6 +24,7 @@ static const char* update_prepare_result_descr[] = {
[UpdatePrepareResultStageIntegrityError] = "Corrupted Stage2 loader",
[UpdatePrepareResultManifestPointerError] = "Failed to create update pointer file",
[UpdatePrepareResultOutdatedManifestVersion] = "Update package is too old",
[UpdatePrepareResultIntFull] = "Need more free space in internal storage",
};
const char* update_operation_describe_preparation_result(const UpdatePrepareResult value) {
@ -133,15 +136,22 @@ static bool update_operation_persist_manifest_path(Storage* storage, const char*
}
UpdatePrepareResult update_operation_prepare(const char* manifest_file_path) {
UpdatePrepareResult result = UpdatePrepareResultManifestFolderNotFound;
UpdatePrepareResult result = UpdatePrepareResultIntFull;
Storage* storage = furi_record_open("storage");
UpdateManifest* manifest = update_manifest_alloc();
File* file = storage_file_alloc(storage);
uint64_t free_int_space;
string_t stage_path;
string_init(stage_path);
do {
if((storage_common_fs_info(storage, "/int", NULL, &free_int_space) != FSE_OK) ||
(free_int_space < UPDATE_MIN_INT_FREE_SPACE)) {
break;
}
if(storage_common_stat(storage, manifest_file_path, NULL) != FSE_OK) {
result = UpdatePrepareResultManifestFolderNotFound;
break;
}

2
lib/update_util/update_operation.h
View file

@ -32,6 +32,8 @@ typedef enum {
UpdatePrepareResultManifestPointerError,
UpdatePrepareResultTargetMismatch,
UpdatePrepareResultOutdatedManifestVersion,
UpdatePrepareResultIntFull,
UpdatePrepareResultUnspecifiedError,
} UpdatePrepareResult;
const char* update_operation_describe_preparation_result(const UpdatePrepareResult value);

15
scripts/selfupdate.py
View file

@ -76,12 +76,15 @@ class Main(App):
manifest_name, pkg_name = manifest_path.parts[-1], manifest_path.parts[-2]
pkg_dir_name = self.args.pkg_dir_name or pkg_name
flipper_update_path = f"/ext/update/{pkg_dir_name}"
update_root = "/ext/update"
flipper_update_path = f"{update_root}/{pkg_dir_name}"
self.logger.info(f'Installing "{pkg_name}" from {flipper_update_path}')
# if not os.path.exists(self.args.manifest_path):
# self.logger.error("Error: package not found")
if not self.mkdir_on_storage(storage, flipper_update_path):
if not self.mkdir_on_storage(
storage, update_root
) or not self.mkdir_on_storage(storage, flipper_update_path):
self.logger.error(f"Error: cannot create {storage.last_error}")
return -2
@ -99,6 +102,14 @@ class Main(App):
storage.send_and_wait_eol(
f"update install {flipper_update_path}/{manifest_name}\r"
)
result = storage.read.until(storage.CLI_EOL)
if not b"Verifying" in result:
self.logger.error(f"Unexpected response: {result.decode('ascii')}")
return -4
result = storage.read.until(storage.CLI_EOL)
if not result.startswith(b"OK"):
self.logger.error(result.decode("ascii"))
return -5
break
return 0
finally:

6
site_scons/commandline.scons
View file

@ -162,6 +162,12 @@ vars.Add(
default="",
)
vars.Add(
"BLACKMAGIC",
help="Blackmagic probe location",
default="auto",
)
vars.Add(
"UPDATE_SPLASH",
help="Directory name with slideshow frames to render after installing update package",

1
site_scons/environ.scons
View file

@ -78,5 +78,6 @@ coreenv["TEMPFILEARGESCFUNC"] = util.tempfile_arg_esc_func
util.wrap_tempfile(coreenv, "LINKCOM")
util.wrap_tempfile(coreenv, "ARCOM")
coreenv["SINGLEQUOTEFUNC"] = util.single_quote
Return("coreenv")

4
site_scons/fbt/util.py
View file

@ -42,3 +42,7 @@ def random_alnum(length):
return "".join(
random.choice(string.ascii_letters + string.digits) for _ in range(length)
)
def single_quote(arg_list):
return " ".join(f"'{arg}'" if " " in arg else str(arg) for arg in arg_list)

74
site_scons/site_tools/blackmagic.py Normal file
View file

@ -0,0 +1,74 @@
from SCons.Errors import StopError
class BlackmagicResolver:
BLACKMAGIC_HOSTNAME = "blackmagic.local"
def __init__(self, env):
self.env = env
# On Win:
# 'location': '1-5:x.0', 'name': 'COM4',
# 'location': '1-5:x.2', 'name': 'COM13',
# On Linux:
# 'location': '1-1.2:1.0', 'name': 'ttyACM0',
# 'location': '1-1.2:1.2', 'name': 'ttyACM1',
# On MacOS:
# 'location': '0-1.3', 'name': 'cu.usbmodemblackmagic1',
# 'location': '0-1.3', 'name': 'cu.usbmodemblackmagic3',
def _find_probe(self):
import serial.tools.list_ports as list_ports
ports = list(list_ports.grep("blackmagic"))
if len(ports) == 0:
# Blackmagic probe serial port not found, will be handled later
pass
elif len(ports) > 2:
raise StopError("More than one Blackmagic probe found")
else:
# If you're getting any issues with auto lookup, uncomment this
# print("\n".join([f"{p.device} {vars(p)}" for p in ports]))
return sorted(ports, key=lambda p: f"{p.location}_{p.name}")[0]
# Look up blackmagic probe hostname with dns
def _resolve_hostname(self):
import socket
try:
return socket.gethostbyname(self.BLACKMAGIC_HOSTNAME)
except socket.gaierror:
print("Failed to resolve Blackmagic hostname")
return None
def get_serial(self):
if not (probe := self._find_probe()):
return None
# print(f"Found Blackmagic probe on {probe.device}")
if self.env.subst("$PLATFORM") == "win32":
return f"\\\\.\\{probe.device}"
return probe.device
def get_networked(self):
if not (probe := self._resolve_hostname()):
return None
return f"tcp:{probe}:2345"
def __str__(self):
# print("distenv blackmagic", self.env.subst("$BLACKMAGIC"))
if (blackmagic := self.env.subst("$BLACKMAGIC")) != "auto":
return blackmagic
# print("Looking for Blackmagic...")
if probe := self.get_serial() or self.get_networked():
return probe
raise Exception("Please specify BLACKMAGIC=...")
def generate(env):
env.SetDefault(BLACKMAGIC_ADDR=BlackmagicResolver(env))
def exists(env):
return True

29
site_scons/site_tools/fbt_dist.py
View file

@ -54,20 +54,20 @@ def AddFwProject(env, base_env, fw_type, fw_env_key):
return project_env
def AddDebugTarget(env, alias, targetenv, force_flash=True):
debug_target = env.PhonyTarget(
alias,
"$GDBPYCOM",
source=targetenv["FW_ELF"],
GDBPYOPTS='-ex "source debug/FreeRTOS/FreeRTOS.py" '
'-ex "source debug/PyCortexMDebug/PyCortexMDebug.py" '
'-ex "svd_load ${SVD_FILE}" '
'-ex "compare-sections"',
def AddOpenOCDFlashTarget(env, targetenv, **kw):
openocd_target = env.OpenOCDFlash(
"#build/oocd-${BUILD_CFG}-flash.flag",
targetenv["FW_BIN"],
OPENOCD_COMMAND=[
"-c",
"program ${SOURCE.posix} reset exit ${BASE_ADDRESS}",
],
BUILD_CFG=targetenv.subst("$FIRMWARE_BUILD_CFG"),
BASE_ADDRESS=targetenv.subst("$IMAGE_BASE_ADDRESS"),
**kw,
)
if force_flash:
env.Depends(debug_target, targetenv["FW_FLASH"])
return debug_target
env.Alias(targetenv.subst("${FIRMWARE_BUILD_CFG}_flash"), openocd_target)
return openocd_target
def DistCommand(env, name, source, **kw):
@ -85,8 +85,9 @@ def DistCommand(env, name, source, **kw):
def generate(env):
env.AddMethod(AddFwProject)
env.AddMethod(AddDebugTarget)
env.AddMethod(DistCommand)
env.AddMethod(AddOpenOCDFlashTarget)
env.SetDefault(
COPRO_MCU_FAMILY="STM32WB5x",
)

6
site_scons/site_tools/sconsmodular.py
View file

@ -34,9 +34,9 @@ def PhonyTarget(env, name, action, source=None, **kw):
source = []
phony_name = "phony_" + name
env.Pseudo(phony_name)
return env.AlwaysBuild(
env.Alias(name, env.Command(phony_name, source, action, **kw))
)
command = env.Command(phony_name, source, action, **kw)
env.AlwaysBuild(env.Alias(name, command))
return command
def generate(env):