WIP debug console for testing playback

src/dev_console/CMakeLists.txt

@@ -0,0 +1,5 @@
+idf_component_register(
+  SRCS "console.cpp"
+  INCLUDE_DIRS "include"
+  REQUIRES "console")
+target_compile_options(${COMPONENT_LIB} PRIVATE ${EXTRA_WARNINGS})

src/dev_console/console.cpp

@@ -0,0 +1,87 @@
+#include "console.hpp"
+#include <stdio.h>
+#include <string.h>
+
+#include <algorithm>
+#include <iostream>
+#include <string>
+
+#include "esp_console.h"
+#include "esp_log.h"
+#include "esp_system.h"
+
+namespace console {
+
+int CmdLogLevel(int argc, char** argv) {
+  static const std::string usage =
+      "usage: loglevel [VERBOSE,DEBUG,INFO,WARN,ERROR,NONE]";
+  if (argc != 2) {
+    std::cout << usage << std::endl;
+    return 1;
+  }
+  std::string level_str = argv[1];
+  std::transform(level_str.begin(), level_str.end(), level_str.begin(),
+                 [](unsigned char c) { return std::toupper(c); });
+
+  esp_log_level_t level;
+  if (level_str == "VERBOSE") {
+    level = ESP_LOG_VERBOSE;
+  } else if (level_str == "DEBUG") {
+    level = ESP_LOG_DEBUG;
+  } else if (level_str == "INFO") {
+    level = ESP_LOG_INFO;
+  } else if (level_str == "WARN") {
+    level = ESP_LOG_WARN;
+  } else if (level_str == "ERROR") {
+    level = ESP_LOG_ERROR;
+  } else if (level_str == "NONE") {
+    level = ESP_LOG_NONE;
+  } else {
+    std::cout << usage << std::endl;
+    return 1;
+  }
+
+  esp_log_level_set("*", level);
+
+  return 0;
+}
+
+void RegisterLogLevel() {
+  esp_console_cmd_t cmd{
+      .command = "loglevel",
+      .help =
+          "Sets the log level to one of \"VERBOSE\", \"DEBUG\", \"INFO\", "
+          "\"WARN\", \"ERROR\", \"NONE\"",
+      .hint = "level",
+      .func = &CmdLogLevel,
+      .argtable = NULL};
+  esp_console_cmd_register(&cmd);
+}
+
+Console::Console() {}
+Console::~Console() {}
+
+auto Console::RegisterCommonComponents() -> void {
+  esp_console_register_help_command();
+  RegisterLogLevel();
+}
+
+auto Console::Launch() -> void {
+  esp_console_repl_t* repl = nullptr;
+  esp_console_repl_config_t repl_config = ESP_CONSOLE_REPL_CONFIG_DEFAULT();
+  repl_config.max_history_len = 16;
+  repl_config.prompt = " →";
+  repl_config.max_cmdline_length = 256;
+  repl_config.task_stack_size = 1024 * GetStackSizeKiB();
+
+  esp_console_dev_uart_config_t hw_config =
+      ESP_CONSOLE_DEV_UART_CONFIG_DEFAULT();
+  ESP_ERROR_CHECK(esp_console_new_repl_uart(&hw_config, &repl_config, &repl));
+
+  RegisterCommonComponents();
+  RegisterExtraComponents();
+
+  ESP_ERROR_CHECK(esp_console_start_repl(repl));
+}
+
+}  // namespace console

src/dev_console/include/console.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <cstdint>
+
+namespace console {
+
+class Console {
+ public:
+  Console();
+  virtual ~Console();
+
+  auto Launch() -> void;
+
+ protected:
+  virtual auto GetStackSizeKiB() -> uint16_t { return 0; }
+  virtual auto RegisterExtraComponents() -> void {}
+
+ private:
+  auto RegisterCommonComponents() -> void;
+};
+
+}  // namespace console

src/drivers/audio_playback.cpp

@@ -124,6 +124,14 @@ void AudioPlayback::Play(const std::string& filename) {
   output_->SetVolume(volume_);
 }
 
+void AudioPlayback::Toggle() {
+  if (GetPlaybackState() == PLAYING) {
+    Pause();
+  } else if (GetPlaybackState() == PAUSED) {
+    Resume();
+  }
+}
+
 void AudioPlayback::Resume() {
   if (GetPlaybackState() == PAUSED) {
     current_state_ = PLAYING;

src/main/CMakeLists.txt

@@ -1,4 +1,5 @@
 idf_component_register(
-  SRCS "main.cpp"
-  REQUIRES "drivers")
+  SRCS "main.cpp" "app_console.cpp"
+  INCLUDE_DIRS "."
+  REQUIRES "drivers" "dev_console")
 target_compile_options(${COMPONENT_LIB} PRIVATE ${EXTRA_WARNINGS})

src/main/app_console.cpp

@@ -0,0 +1,104 @@
+#include "app_console.hpp"
+
+#include <dirent.h>
+#include <cstdio>
+#include <iostream>
+#include <string>
+#include "esp_console.h"
+
+namespace console {
+
+static AppConsole* sInstance = nullptr;
+
+int CmdListDir(int argc, char** argv) {
+  static const std::string usage = "usage: ls [directory]";
+  if (argc > 2) {
+    std::cout << usage << std::endl;
+    return 1;
+  }
+  std::string path = drivers::kStoragePath;
+  if (argc == 2) {
+    path += "/";
+    path += argv[1];
+  }
+
+  DIR* dir;
+  struct dirent* ent;
+  dir = opendir(path.c_str());
+  while ((ent = readdir(dir))) {
+    std::cout << ent->d_name << std::endl;
+  }
+  closedir(dir);
+
+  return 0;
+}
+
+void RegisterListDir() {
+  esp_console_cmd_t cmd{.command = "ls",
+                        .help = "Lists SD contents",
+                        .hint = NULL,
+                        .func = &CmdListDir,
+                        .argtable = NULL};
+  esp_console_cmd_register(&cmd);
+}
+
+int CmdPlayFile(int argc, char** argv) {
+  static const std::string usage = "usage: play [file]";
+  if (argc != 2) {
+    std::cout << usage << std::endl;
+    return 1;
+  }
+  std::string path = drivers::kStoragePath;
+  path += "/";
+  path += argv[1];
+
+  sInstance->playback_->Play(path.c_str());
+
+  return 0;
+}
+
+void RegisterPlayFile() {
+  esp_console_cmd_t cmd{.command = "play",
+                        .help = "Begins playback of the file at the given path",
+                        .hint = "filepath",
+                        .func = &CmdPlayFile,
+                        .argtable = NULL};
+  esp_console_cmd_register(&cmd);
+}
+
+int CmdToggle(int argc, char** argv) {
+  static const std::string usage = "usage: toggle";
+  if (argc != 1) {
+    std::cout << usage << std::endl;
+    return 1;
+  }
+
+  sInstance->playback_->Toggle();
+
+  return 0;
+}
+
+void RegisterToggle() {
+  esp_console_cmd_t cmd{.command = "toggle",
+                        .help = "Toggles between play and pause",
+                        .hint = NULL,
+                        .func = &CmdToggle,
+                        .argtable = NULL};
+  esp_console_cmd_register(&cmd);
+}
+
+AppConsole::AppConsole(std::unique_ptr<drivers::AudioPlayback> playback)
+    : playback_(std::move(playback)) {
+  sInstance = this;
+}
+AppConsole::~AppConsole() {
+  sInstance = nullptr;
+}
+
+auto AppConsole::RegisterExtraComponents() -> void {
+  RegisterListDir();
+  RegisterPlayFile();
+  RegisterToggle();
+}
+
+}  // namespace console

src/main/app_console.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "audio_playback.hpp"
+#include "console.hpp"
+
+#include <memory>
+
+namespace console {
+
+class AppConsole : public Console {
+ public:
+  AppConsole(std::unique_ptr<drivers::AudioPlayback> playback);
+  virtual ~AppConsole();
+
+  std::unique_ptr<drivers::AudioPlayback> playback_;
+
+ protected:
+  virtual auto RegisterExtraComponents() -> void;
+};
+
+}  // namespace console

src/main/main.cpp

@@ -1,3 +1,5 @@
+#include "app_console.hpp"
+#include "audio_playback.hpp"
 #include "battery.hpp"
 #include "core/lv_disp.h"
 #include "core/lv_obj_pos.h"
@@ -11,8 +13,6 @@
 #include "i2s_audio_output.hpp"
 #include "misc/lv_color.h"
 #include "misc/lv_timer.h"
-#include "audio_playback.hpp"
-#include "i2s_audio_output.hpp"
 #include "spi.hpp"
 #include "storage.hpp"
 
@@ -114,7 +114,7 @@ extern "C" void app_main(void) {
                                 (void*)lvglArgs, 1, sLvglStack,
                                 &sLvglTaskBuffer, 1);
 
-  ESP_LOGI(TAG, "Init Audio Output (I2S)");
+  ESP_LOGI(TAG, "Init audio output (I2S)");
   auto sink_res = drivers::I2SAudioOutput::create(expander);
   if (sink_res.has_error()) {
     ESP_LOGE(TAG, "Failed: %d", sink_res.error());
@@ -122,7 +122,7 @@ extern "C" void app_main(void) {
   }
   std::unique_ptr<drivers::IAudioOutput> sink = std::move(sink_res.value());
 
-  ESP_LOGI(TAG, "Init Audio Pipeline");
+  ESP_LOGI(TAG, "Init audio pipeline");
   auto playback_res = drivers::AudioPlayback::create(std::move(sink));
   if (playback_res.has_error()) {
     ESP_LOGE(TAG, "Failed: %d", playback_res.error());
@@ -131,8 +131,9 @@ extern "C" void app_main(void) {
   std::unique_ptr<drivers::AudioPlayback> playback =
       std::move(playback_res.value());
 
-  ESP_LOGI(TAG, "Everything looks good! Waiting a mo for debugger.");
-  vTaskDelay(pdMS_TO_TICKS(1500));
+  ESP_LOGI(TAG, "Launch console");
+  console::AppConsole console(std::move(playback));
+  console.Launch();
 
   while (1) {
     playback->ProcessEvents(5);