[FL-3211][FL-3212] Debug apps: speaker, uart_echo with baudrate

applications/debug/application.fam

@@ -12,5 +12,6 @@ App(
         "display_test",
         "text_box_test",
         "file_browser_test",
+        "speaker_debug",
     ],
 )

applications/debug/speaker_debug/application.fam

@@ -0,0 +1,11 @@
+App(
+    appid="speaker_debug",
+    name="Speaker Debug",
+    apptype=FlipperAppType.DEBUG,
+    entry_point="speaker_debug_app",
+    requires=["gui", "notification"],
+    stack_size=2 * 1024,
+    order=10,
+    fap_category="Debug",
+    fap_libs=["music_worker"],
+)

applications/debug/speaker_debug/speaker_debug.c

@@ -0,0 +1,120 @@
+#include <furi.h>
+#include <notification/notification.h>
+#include <music_worker/music_worker.h>
+#include <cli/cli.h>
+#include <toolbox/args.h>
+
+#define TAG "SpeakerDebug"
+#define CLI_COMMAND "speaker_debug"
+
+typedef enum {
+    SpeakerDebugAppMessageTypeStop,
+} SpeakerDebugAppMessageType;
+
+typedef struct {
+    SpeakerDebugAppMessageType type;
+} SpeakerDebugAppMessage;
+
+typedef struct {
+    MusicWorker* music_worker;
+    FuriMessageQueue* message_queue;
+    Cli* cli;
+} SpeakerDebugApp;
+
+static SpeakerDebugApp* speaker_app_alloc() {
+    SpeakerDebugApp* app = (SpeakerDebugApp*)malloc(sizeof(SpeakerDebugApp));
+    app->music_worker = music_worker_alloc();
+    app->message_queue = furi_message_queue_alloc(8, sizeof(SpeakerDebugAppMessage));
+    app->cli = furi_record_open(RECORD_CLI);
+    return app;
+}
+
+static void speaker_app_free(SpeakerDebugApp* app) {
+    music_worker_free(app->music_worker);
+    furi_message_queue_free(app->message_queue);
+    furi_record_close(RECORD_CLI);
+    free(app);
+}
+
+static void speaker_app_cli(Cli* cli, FuriString* args, void* context) {
+    UNUSED(cli);
+
+    SpeakerDebugApp* app = (SpeakerDebugApp*)context;
+    SpeakerDebugAppMessage message;
+    FuriString* cmd = furi_string_alloc();
+
+    if(!args_read_string_and_trim(args, cmd)) {
+        furi_string_free(cmd);
+        printf("Usage:\r\n");
+        printf("\t" CLI_COMMAND " stop\r\n");
+        return;
+    }
+
+    if(furi_string_cmp(cmd, "stop") == 0) {
+        message.type = SpeakerDebugAppMessageTypeStop;
+        FuriStatus status = furi_message_queue_put(app->message_queue, &message, 100);
+        if(status != FuriStatusOk) {
+            printf("Failed to send message\r\n");
+        } else {
+            printf("Stopping\r\n");
+        }
+    } else {
+        printf("Usage:\r\n");
+        printf("\t" CLI_COMMAND " stop\r\n");
+    }
+
+    furi_string_free(cmd);
+}
+
+static bool speaker_app_music_play(SpeakerDebugApp* app, const char* rtttl) {
+    if(music_worker_is_playing(app->music_worker)) {
+        music_worker_stop(app->music_worker);
+    }
+
+    if(!music_worker_load_rtttl_from_string(app->music_worker, rtttl)) {
+        FURI_LOG_E(TAG, "Failed to load RTTTL");
+        return false;
+    }
+
+    music_worker_set_volume(app->music_worker, 1.0f);
+    music_worker_start(app->music_worker);
+
+    return true;
+}
+
+static void speaker_app_music_stop(SpeakerDebugApp* app) {
+    if(music_worker_is_playing(app->music_worker)) {
+        music_worker_stop(app->music_worker);
+    }
+}
+
+static void speaker_app_run(SpeakerDebugApp* app, const char* arg) {
+    if(!arg || !speaker_app_music_play(app, arg)) {
+        FURI_LOG_E(TAG, "Provided RTTTL is invalid");
+        return;
+    }
+
+    cli_add_command(app->cli, CLI_COMMAND, CliCommandFlagParallelSafe, speaker_app_cli, app);
+
+    SpeakerDebugAppMessage message;
+    FuriStatus status;
+    while(true) {
+        status = furi_message_queue_get(app->message_queue, &message, FuriWaitForever);
+
+        if(status == FuriStatusOk) {
+            if(message.type == SpeakerDebugAppMessageTypeStop) {
+                speaker_app_music_stop(app);
+                break;
+            }
+        }
+    }
+
+    cli_delete_command(app->cli, CLI_COMMAND);
+}
+
+int32_t speaker_debug_app(void* arg) {
+    SpeakerDebugApp* app = speaker_app_alloc();
+    speaker_app_run(app, arg);
+    speaker_app_free(app);
+    return 0;
+}

applications/debug/uart_echo/uart_echo.c

@@ -10,6 +10,8 @@
 
 #define LINES_ON_SCREEN 6
 #define COLUMNS_ON_SCREEN 21
+#define TAG "UartEcho"
+#define DEFAULT_BAUD_RATE 230400
 
 typedef struct UartDumpModel UartDumpModel;
 
@@ -179,7 +181,7 @@ static int32_t uart_echo_worker(void* context) {
     return 0;
 }
 
-static UartEchoApp* uart_echo_app_alloc() {
+static UartEchoApp* uart_echo_app_alloc(uint32_t baudrate) {
     UartEchoApp* app = malloc(sizeof(UartEchoApp));
 
     app->rx_stream = furi_stream_buffer_alloc(2048, 1);
@@ -220,7 +222,7 @@ static UartEchoApp* uart_echo_app_alloc() {
 
     // Enable uart listener
     furi_hal_console_disable();
-    furi_hal_uart_set_br(FuriHalUartIdUSART1, 115200);
+    furi_hal_uart_set_br(FuriHalUartIdUSART1, baudrate);
     furi_hal_uart_set_irq_cb(FuriHalUartIdUSART1, uart_echo_on_irq_cb, app);
 
     return app;
@@ -263,8 +265,18 @@ static void uart_echo_app_free(UartEchoApp* app) {
 }
 
 int32_t uart_echo_app(void* p) {
-    UNUSED(p);
-    UartEchoApp* app = uart_echo_app_alloc();
+    uint32_t baudrate = DEFAULT_BAUD_RATE;
+    if(p) {
+        const char* baudrate_str = p;
+        if(sscanf(baudrate_str, "%lu", &baudrate) != 1) {
+            FURI_LOG_E(TAG, "Invalid baudrate: %s", baudrate_str);
+            baudrate = DEFAULT_BAUD_RATE;
+        }
+    }
+
+    FURI_LOG_I(TAG, "Using baudrate: %lu", baudrate);
+
+    UartEchoApp* app = uart_echo_app_alloc(baudrate);
     view_dispatcher_run(app->view_dispatcher);
     uart_echo_app_free(app);
     return 0;

applications/external/music_player/application.fam

@@ -7,18 +7,10 @@ App(
         "gui",
         "dialogs",
     ],
-    provides=["music_player_start"],
     stack_size=2 * 1024,
     order=20,
     fap_icon="icons/music_10px.png",
     fap_category="Media",
     fap_icon_assets="icons",
-)
-
-App(
-    appid="music_player_start",
-    apptype=FlipperAppType.STARTUP,
-    entry_point="music_player_on_system_start",
-    requires=["music_player"],
-    order=30,
+    fap_libs=["music_worker"],
 )

applications/external/music_player/music_player.c

@@ -1,4 +1,4 @@
-#include "music_player_worker.h"
+#include <music_worker/music_worker.h>
 
 #include <furi.h>
 #include <furi_hal.h>
@@ -34,7 +34,7 @@ typedef struct {
     ViewPort* view_port;
     Gui* gui;
 
-    MusicPlayerWorker* worker;
+    MusicWorker* worker;
 } MusicPlayer;
 
 static const float MUSIC_PLAYER_VOLUMES[] = {0, .25, .5, .75, 1};
@@ -218,7 +218,7 @@ static void input_callback(InputEvent* input_event, void* ctx) {
     }
 }
 
-static void music_player_worker_callback(
+static void music_worker_callback(
     uint8_t semitone,
     uint8_t dots,
     uint8_t duration,
@@ -250,7 +250,7 @@ static void music_player_worker_callback(
 void music_player_clear(MusicPlayer* instance) {
     memset(instance->model->duration_history, 0xff, MUSIC_PLAYER_SEMITONE_HISTORY_SIZE);
     memset(instance->model->semitone_history, 0xff, MUSIC_PLAYER_SEMITONE_HISTORY_SIZE);
-    music_player_worker_clear(instance->worker);
+    music_worker_clear(instance->worker);
 }
 
 MusicPlayer* music_player_alloc() {
@@ -263,10 +263,9 @@ MusicPlayer* music_player_alloc() {
 
     instance->input_queue = furi_message_queue_alloc(8, sizeof(InputEvent));
 
-    instance->worker = music_player_worker_alloc();
-    music_player_worker_set_volume(
-        instance->worker, MUSIC_PLAYER_VOLUMES[instance->model->volume]);
-    music_player_worker_set_callback(instance->worker, music_player_worker_callback, instance);
+    instance->worker = music_worker_alloc();
+    music_worker_set_volume(instance->worker, MUSIC_PLAYER_VOLUMES[instance->model->volume]);
+    music_worker_set_callback(instance->worker, music_worker_callback, instance);
 
     music_player_clear(instance);
 
@@ -286,7 +285,7 @@ void music_player_free(MusicPlayer* instance) {
     furi_record_close(RECORD_GUI);
     view_port_free(instance->view_port);
 
-    music_player_worker_free(instance->worker);
+    music_worker_free(instance->worker);
 
     furi_message_queue_free(instance->input_queue);
 
@@ -330,12 +329,12 @@ int32_t music_player_app(void* p) {
             }
         }
 
-        if(!music_player_worker_load(music_player->worker, furi_string_get_cstr(file_path))) {
+        if(!music_worker_load(music_player->worker, furi_string_get_cstr(file_path))) {
             FURI_LOG_E(TAG, "Unable to load file");
             break;
         }
 
-        music_player_worker_start(music_player->worker);
+        music_worker_start(music_player->worker);
 
         InputEvent input;
         while(furi_message_queue_get(music_player->input_queue, &input, FuriWaitForever) ==
@@ -349,19 +348,19 @@ int32_t music_player_app(void* p) {
             } else if(input.key == InputKeyUp) {
                 if(music_player->model->volume < COUNT_OF(MUSIC_PLAYER_VOLUMES) - 1)
                     music_player->model->volume++;
-                music_player_worker_set_volume(
+                music_worker_set_volume(
                     music_player->worker, MUSIC_PLAYER_VOLUMES[music_player->model->volume]);
             } else if(input.key == InputKeyDown) {
                 if(music_player->model->volume > 0) music_player->model->volume--;
-                music_player_worker_set_volume(
+                music_worker_set_volume(
                     music_player->worker, MUSIC_PLAYER_VOLUMES[music_player->model->volume]);
             }
 
             furi_mutex_release(music_player->model_mutex);
             view_port_update(music_player->view_port);
         }
 
-        music_player_worker_stop(music_player->worker);
+        music_worker_stop(music_player->worker);
         if(p && strlen(p)) break; // Exit instead of going to browser if launched with arg
         music_player_clear(music_player);
     } while(1);