Start and Shutdown of scheduler in simulator

2026-08-09 17:18:49 +02:00
parent 7ea52cb96a
commit 123a6e71b4
5 changed files with 309 additions and 30 deletions
@@ -61,6 +61,12 @@ typedef bool (*nova64_sd_read_sector_cb_t)(uint32_t sector_idx,
 typedef void (*nova64_cartridge_status_cb_t)(uint32_t slot_idx,
                                            bool is_inserted);

+/**
+ * @brief Callback for core log output.
+ * @param message Null-terminated UTF-8 log string.
+ */
+typedef void (*nova64_log_cb_t)(const char *message);
+
 /* ========================================================================== */
 /* I/O Interface Configuration Struct                                         */
 /* ========================================================================== */
@@ -74,6 +80,7 @@ typedef struct {
  nova64_audio_output_cb_t audio_output;
  nova64_sd_read_sector_cb_t sd_read_sector;
  nova64_cartridge_status_cb_t cartridge_status;
+  nova64_log_cb_t log_message;
 } nova64_io_interface_t;

 /* ========================================================================== */
@@ -81,21 +88,26 @@ typedef struct {
 /* ========================================================================== */

 /**
- * @brief Initializes the core engine and registers host I/O interface
- * callbacks.
+ * @brief Initializes the core engine, registers host I/O interface callbacks,
+ * and starts the built-in launcher from internal storage in the WASM runtime.
 * @param io_interface Pointer to filled struct containing I/O function
 * pointers.
 * @return True if initialized successfully, false if already initialized or
 * invalid.
 */
-NOVA64_API bool nova64_init_io(const nova64_io_interface_t *io_interface);
+NOVA64_API bool nova64_init(const nova64_io_interface_t *io_interface);

 /**
- * @brief Executes one engine processing tick.
- * @param delta_ms Elapsed time in milliseconds since the last tick.
+ * @brief Starts the main engine runtime and launches the FreeRTOS scheduler.
 * @return 0 on success, negative error code on failure.
 */
-NOVA64_API int32_t nova64_process_tick(uint32_t delta_ms);
+NOVA64_API int32_t nova64_main();
+
+/**
+ * @brief Requests shutdown of the FreeRTOS scheduler.
+ * @return True if the shutdown request was issued, false otherwise.
+ */
+NOVA64_API bool nova64_shutdown(void);

 /**
 * @brief Retrieves the engine version integer.
@@ -2,6 +2,7 @@
 #include "FreeRTOS.h"
 #include "queue.h"
 #include "task.h"
+#include <stdarg.h>
 #include <stdio.h>

 #if defined(ESP_PLATFORM)
@@ -19,23 +20,179 @@
 #endif

 static bool is_initialized = false;
+static nova64_io_interface_t g_io_interface_storage;
+static const nova64_io_interface_t *g_io_interface = NULL;
 static QueueHandle_t event_queue = NULL;
+static TaskHandle_t boot_task_handle = NULL;
+static TaskHandle_t launcher_task_handle = NULL;
+static TaskHandle_t shutdown_task_handle = NULL;
+static volatile bool shutdown_requested = false;

+static const char *const kInternalLauncherPath = "SYS:/launcher.wasm";

-NOVA64_API bool nova64_init_io(const nova64_io_interface_t *io_interface) {
-  printf("[Nova64 Core] System Initializing...\n");
+static void nova64_log(const char *format, ...) {
+  char buffer[512];
+  va_list args;
+  va_start(args, format);
+  vsnprintf(buffer, sizeof(buffer), format, args);
+  va_end(args);
+
+  if (g_io_interface && g_io_interface->log_message) {
+    g_io_interface->log_message(buffer);
+  } else {
+    fputs(buffer, stdout);
+  }
+}
+
+static bool initialize_wasm_runtime(void) {
+  nova64_log("[Core] Initializing WASM runtime...\n");
+  // TODO: Replace this stub with real WAMR initialization.
+  return true;
+}
+
+static bool load_launcher_from_internal_storage(void) {
+  nova64_log("[Core] Loading launcher from internal storage (%s)...\n",
+             kInternalLauncherPath);
+  // TODO: Implement the actual internal storage filesystem and launcher load.
+  return true;
+}
+
+static void nova64_wasm_launcher_task(void *params) {
+  (void)params;
+  nova64_log("[Core] WASM launcher task started.\n");
+
+  // TODO: Execute the loaded WASM launcher module here with the WAMR engine.
+  for (;;) {
+    vTaskDelay(pdMS_TO_TICKS(1000));
+  }
+}
+
+static bool start_launcher_task(void) {
+  BaseType_t result = xTaskCreate(nova64_wasm_launcher_task, "Nova64Launcher",
+                                  4096 / sizeof(StackType_t), NULL,
+                                  tskIDLE_PRIORITY + 1, &launcher_task_handle);
+
+  if (result != pdPASS) {
+    nova64_log("[Core] Failed to create launcher task.\n");
+    return false;
+  }
+
+  nova64_log("[Core] Launcher task created successfully.\n");
+  return true;
+}
+
+static void nova64_shutdown_task(void *params) {
+  (void)params;
+
+  nova64_log("[Core] Shutdown task started.\n");
+  for (;;) {
+    if (shutdown_requested) {
+      nova64_log("[Core] Shutdown requested; ending scheduler.\n");
+      vTaskEndScheduler();
+      return;
+    }
+    vTaskDelay(pdMS_TO_TICKS(100));
+  }
+}
+
+static bool start_shutdown_task(void) {
+  BaseType_t result = xTaskCreate(nova64_shutdown_task, "Nova64Shutdown",
+                                  2048 / sizeof(StackType_t), NULL,
+                                  tskIDLE_PRIORITY + 2, &shutdown_task_handle);
+
+  if (result != pdPASS) {
+    nova64_log("[Core] Failed to create shutdown task.\n");
+    return false;
+  }
+
+  nova64_log("[Core] Shutdown task created successfully.\n");
+  return true;
+}
+
+static void nova64_boot_task(void *params) {
+  (void)params;
+  nova64_log("[Core] Boot task started.\n");
+
+  if (!initialize_wasm_runtime()) {
+    nova64_log("[Core] WASM runtime initialization failed.\n");
+    vTaskDelete(NULL);
+    return;
+  }
+
+  if (!load_launcher_from_internal_storage()) {
+    nova64_log("[Core] Launcher loading failed.\n");
+    vTaskDelete(NULL);
+    return;
+  }
+
+  if (!start_launcher_task()) {
+    nova64_log("[Core] Launcher startup failed.\n");
+    vTaskDelete(NULL);
+    return;
+  }
+
+  nova64_log("[Core] Boot process completed.\n");
+  vTaskDelete(NULL);
+}
+
+NOVA64_API bool nova64_init(const nova64_io_interface_t *io_interface) {
+  if (is_initialized || io_interface == NULL) {
+    return false;
+  }
+
+  g_io_interface_storage = *io_interface;
+  g_io_interface = &g_io_interface_storage;
+  shutdown_requested = false;
+
+  nova64_log("[Core] System Initializing...\n");

  event_queue = xQueueCreate(10, sizeof(uint32_t));
+  if (event_queue == NULL) {
+    nova64_log("[Core] Failed to create event queue.\n");
+    return false;
+  }
+
+  if (!start_shutdown_task()) {
+    return false;
+  }
+
+  nova64_log("[Core] Starting boot process...\n");
+  BaseType_t created =
+      xTaskCreate(nova64_boot_task, "Nova64Boot", 4096 / sizeof(StackType_t),
+                  NULL, tskIDLE_PRIORITY + 2, &boot_task_handle);
+  if (created != pdPASS) {
+    nova64_log("[Core] Failed to create boot task.\n");
+    return false;
+  }

  is_initialized = true;
  return true;
 }

-NOVA64_API int32_t nova64_process_tick(uint32_t delta_ms) {
-  if (!is_initialized)
+NOVA64_API int32_t nova64_main() {
+  if (!is_initialized) {
    return -1;
-  // Core Game-Logic & State Machine Ticks
-  return 0; // OK
+  }
+
+  nova64_log(
+      "[Core] Entering main runtime and starting FreeRTOS scheduler...\n");
+  vTaskStartScheduler();
+
+  // vTaskStartScheduler only returns if the scheduler fails to start or if
+  // the scheduler is shut down by vTaskEndScheduler().
+  nova64_log("[Core] vTaskStartScheduler returned.\n");
+  is_initialized = false;
+  return -1;
+}
+
+NOVA64_API bool nova64_shutdown(void) {
+  if (!is_initialized) {
+    return false;
+  }
+
+  nova64_log("[Core] Scheduler shutdown requested from host.\n");
+  shutdown_requested = true;
+  return true;
 }

 NOVA64_API uint32_t nova64_get_version(void) {