main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_app.h"
#include "ra8_attributes.h"
#include "ra8_board_ek_ra8d2_peripherals.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_err.h"
#include "ra8_log.h"
#include "ra8_widget.h"

typedef enum : uint32_t {
  k_app_shell_hil_baud = 115200U, 
} app_shell_hil_t;

static const uint8_t k_app_shell_pass_banner[] = "app_shell_demo: demo PASS\r\n";

static bool app_shell_hil_console_init(void)
{
  if (ra8_cgc_init() != k_ra8_ok) {
    return false;
  }
  if (ra8_board_uart_console_init((uint32_t)k_app_shell_hil_baud) != k_ra8_ok) {
    return false;
  }
  return true;
}

static void app_shell_hil_emit_pass(void)
{
  (void)ra8_board_uart_console_write(k_app_shell_pass_banner,
                                     (size_t)(sizeof(k_app_shell_pass_banner) - 1U));
  (void)ra8_board_uart_console_flush();
}

#ifndef APP_SHELL_SETTINGS
#define APP_SHELL_SETTINGS (1)
#endif

typedef enum : uint16_t {
  k_app_id_library  = 1U, 
  k_app_id_reader   = 2U, 
  k_app_id_settings = 3U, 
} app_shell_id_t;

typedef enum : uint16_t {
  k_app_reg_cap     = 3U, 
  k_app_nav_cap     = 4U, 
  k_app_idx_library = 0U, 
  k_app_btn_back    = 1U, 
} app_shell_const_t;

typedef struct {
  const char* name;    
  uint32_t    inits;   
  uint32_t    enters;  
  uint32_t    leaves;  
  uint32_t    renders; 
  uint32_t    inputs;  
  uint32_t    deinits; 
} app_shell_ctx_t;

static ra8_app_registry_t s_reg;

static ra8_app_t* s_slots[k_app_reg_cap];

static uint16_t s_nav_stack[k_app_nav_cap];

static ra8_app_nav_t s_nav;

static app_shell_ctx_t s_library_ctx = {.name = "library"};

static ra8_app_t s_library_app;

static app_shell_ctx_t s_reader_ctx = {.name = "reader"};

static ra8_app_t s_reader_app;
 
#if APP_SHELL_SETTINGS
static app_shell_ctx_t s_settings_ctx = {.name = "settings"};

static ra8_app_t s_settings_app;
#endif
 
/* ===========================================================================
 * Stub-app vtable callbacks (one shared vtable; behaviour keyed off ctx)
 * ===========================================================================
 */

static ra8_err_t app_stub_init(ra8_app_t* a)
{
  app_shell_ctx_t* c = (app_shell_ctx_t*)a->ctx;
  c->inits++;
  ra8_log_info(c->name, "init");
  return k_ra8_ok;
}

static void app_stub_on_enter(ra8_app_t* a)
{
  app_shell_ctx_t* c = (app_shell_ctx_t*)a->ctx;
  c->enters++;
  ra8_log_info(c->name, "on_enter");
}

static void app_stub_on_leave(ra8_app_t* a)
{
  app_shell_ctx_t* c = (app_shell_ctx_t*)a->ctx;
  c->leaves++;
  ra8_log_info(c->name, "on_leave");
}

static void app_stub_render(const ra8_app_t* a)
{
  app_shell_ctx_t* c = (app_shell_ctx_t*)a->ctx;
  c->renders++;
  ra8_log_info(c->name, "render");
}

static bool app_stub_on_input(ra8_app_t* a, const ra8_widget_event_t* ev)
{
  app_shell_ctx_t* c = (app_shell_ctx_t*)a->ctx;
  c->inputs++;
  if (ev->kind != k_ra8_widget_ev_button) {
    return false;
  }
  if (ev->button_id != (uint16_t)k_app_btn_back) {
    return false;
  }
  ra8_log_info(c->name, "back requested");
  return true;
}

static void app_stub_deinit(ra8_app_t* a)
{
  app_shell_ctx_t* c = (app_shell_ctx_t*)a->ctx;
  c->deinits++;
  ra8_log_info(c->name, "deinit");
}

static const ra8_app_vtable_t k_app_stub_vt = {
  .init     = app_stub_init,
  .on_enter = app_stub_on_enter,
  .tick     = nullptr,
  .render   = app_stub_render,
  .on_input = app_stub_on_input,
  .on_leave = app_stub_on_leave,
  .deinit   = app_stub_deinit,
};
 
/* ===========================================================================
 * Registration + launcher + self-check (the "chrome")
 * ===========================================================================
 */

static bool
app_shell_add(ra8_app_t* app, app_shell_ctx_t* ctx, uint16_t id, const char* name, bool removable)
{
  *app =
    (ra8_app_t){.vt = &k_app_stub_vt, .ctx = ctx, .id = id, .name = name, .removable = removable};
  return (ra8_app_register(&s_reg, app) == k_ra8_ok);
}

static bool app_shell_register(void)
{
  if (ra8_app_registry_init(&s_reg, s_slots, (uint16_t)k_app_reg_cap) != k_ra8_ok) {
    return false;
  }
  if (ra8_app_nav_init(&s_nav, &s_reg, s_nav_stack, (uint16_t)k_app_nav_cap) != k_ra8_ok) {
    return false;
  }
  bool ok =
    app_shell_add(&s_library_app, &s_library_ctx, (uint16_t)k_app_id_library, "library", false);
  if (ok) {
    ok = app_shell_add(&s_reader_app, &s_reader_ctx, (uint16_t)k_app_id_reader, "reader", false);
  }
#if APP_SHELL_SETTINGS
  if (ok) {
    ok = app_shell_add(&s_settings_app,
                       &s_settings_ctx,
                       (uint16_t)k_app_id_settings,
                       "settings",
                       true);
  }
#endif
  return ok;
}

static void app_shell_log_menu(void)
{
  uint16_t n = 0U;
  (void)ra8_app_count(&s_reg, &n);
  RA8_LOOP_BOUND(k_app_reg_cap);
  for (uint16_t i = 0U; i < n; i++) {
    ra8_app_t* app = nullptr;
    if (ra8_app_at(&s_reg, i, &app) == k_ra8_ok) {
      if (app != nullptr) {
        ra8_log_info_val(app->name, app->removable ? "removable" : "core", (uint32_t)app->id);
      }
    }
  }
}

static bool app_shell_launch_library(void)
{
  uint16_t depth = 1U;
  app_shell_log_menu();
  if (ra8_app_nav_go_index(&s_nav, (uint16_t)k_app_idx_library) != k_ra8_ok) {
    return false;
  }
  if (ra8_app_render(&s_reg) != k_ra8_ok) {
    return false;
  }
  if (s_library_ctx.enters != 1U) {
    return false;
  }
  if (ra8_app_nav_depth(&s_nav, &depth) != k_ra8_ok) {
    return false;
  }
  return (depth == 0U);
}

static bool app_shell_open_reader(void)
{
  uint16_t depth = 0U;
  if (ra8_app_nav_go(&s_nav, (uint16_t)k_app_id_reader) != k_ra8_ok) {
    return false;
  }
  if (ra8_app_render(&s_reg) != k_ra8_ok) {
    return false;
  }
  if (s_library_ctx.leaves != 1U) {
    return false;
  }
  if (s_reader_ctx.enters != 1U) {
    return false;
  }
  const ra8_widget_event_t back    = {.kind      = k_ra8_widget_ev_button,
                                      .button_id = (uint16_t)k_app_btn_back};
  bool                     handled = false;
  if (ra8_app_route_input(&s_reg, &back, &handled) != k_ra8_ok) {
    return false;
  }
  if (!handled) {
    return false;
  }
  if (s_reader_ctx.inputs != 1U) {
    return false;
  }
  if (ra8_app_nav_depth(&s_nav, &depth) != k_ra8_ok) {
    return false;
  }
  return (depth == 1U);
}
 
#if APP_SHELL_SETTINGS
static bool app_shell_settings_round_trip(void)
{
  uint16_t depth  = 0U;
  bool     popped = false;
  if (ra8_app_nav_go(&s_nav, (uint16_t)k_app_id_settings) != k_ra8_ok) {
    return false;
  }
  if (ra8_app_render(&s_reg) != k_ra8_ok) {
    return false;
  }
  if (s_reader_ctx.leaves != 1U) {
    return false;
  }
  if (s_settings_ctx.enters != 1U) {
    return false;
  }
  if (ra8_app_nav_depth(&s_nav, &depth) != k_ra8_ok) {
    return false;
  }
  if (depth != 2U) {
    return false;
  }
  if (ra8_app_nav_back(&s_nav, &popped) != k_ra8_ok) {
    return false;
  }
  if (!popped) {
    return false;
  }
  if (s_settings_ctx.leaves != 1U) {
    return false;
  }
  return (s_reader_ctx.enters == 2U);
}
#endif

static bool app_shell_back_to_root(void)
{
  uint16_t depth  = 0U;
  bool     popped = false;
  if (ra8_app_nav_back(&s_nav, &popped) != k_ra8_ok) {
    return false;
  }
  if (!popped) {
    return false;
  }
  if (s_library_ctx.enters != 2U) {
    return false;
  }
  if (ra8_app_nav_depth(&s_nav, &depth) != k_ra8_ok) {
    return false;
  }
  return (depth == 0U);
}
 
#if APP_SHELL_SETTINGS
static bool app_shell_uninstall_demo(void)
{
  /* Core app: uninstall must be refused and tear nothing down. */
  if (ra8_app_uninstall(&s_reg, (uint16_t)k_app_id_library) != k_ra8_err_not_supported) {
    return false;
  }
  if (s_library_ctx.deinits != 0U) {
    return false;
  }
  /* Removable, background app: uninstall unmounts it (deinit fires). */
  if (ra8_app_uninstall(&s_reg, (uint16_t)k_app_id_settings) != k_ra8_ok) {
    return false;
  }
  if (s_settings_ctx.deinits != 1U) {
    return false;
  }
  ra8_app_state_t st = k_ra8_app_state_foreground;
  if (ra8_app_state(&s_reg, (uint16_t)k_app_id_settings, &st) != k_ra8_ok) {
    return false;
  }
  if (st != k_ra8_app_state_unmounted) {
    return false;
  }
  uint16_t n = 0U;
  if (ra8_app_count(&s_reg, &n) != k_ra8_ok) {
    return false;
  }
  return (n == 2U); /* library + reader remain */
}
#endif

static bool app_shell_selfcheck(void)
{
  if (!app_shell_launch_library()) {
    return false;
  }
  if (!app_shell_open_reader()) {
    return false;
  }
#if APP_SHELL_SETTINGS
  if (!app_shell_settings_round_trip()) {
    return false;
  }
#endif
  if (!app_shell_back_to_root()) {
    return false;
  }
#if APP_SHELL_SETTINGS
  if (!app_shell_uninstall_demo()) {
    return false;
  }
#endif
  ra8_app_t* act = nullptr;
  if (ra8_app_active(&s_reg, &act) != k_ra8_ok) {
    return false;
  }
  if (act == nullptr) {
    return false;
  }
  return (act->id == (uint16_t)k_app_id_library);
}

static void app_shell_banner(void)
{
  uint16_t n = 0U;
  (void)ra8_app_count(&s_reg, &n);
  ra8_log_info_val("app_shell", "apps", (uint32_t)n);
  ra8_log_info_val("app_shell", "library enters", s_library_ctx.enters);
  ra8_log_info("app_shell", "app_shell_demo PASS");
  /* Additive HIL banner: the Pi rig has no ITM/SWO capture, so mirror the PASS
   * verdict to the SCI8 / J-Link OB VCOM console for uart_scrape to gate. */
  app_shell_hil_emit_pass();
}

void main(void)
{
  ra8_log_init();
  ra8_log_info("app_shell", "boot");
 
  /* Bring up the VCOM console so the success path can emit the HIL banner.
   * Best-effort: a failure is narrated over ITM and the demo continues. */
  if (!app_shell_hil_console_init()) {
    ra8_log_info("app_shell", "VCOM console init failed -- HIL banner unavailable");
  }
 
  bool ok = app_shell_register();
  if (!ok) {
    ra8_log_info("app_shell", "FAIL register");
  }
  if (ok) {
    ok = app_shell_selfcheck();
    if (!ok) {
      ra8_log_info("app_shell", "FAIL selfcheck");
    }
  }
  if (ok) {
    app_shell_banner();
  }
 
  while (1) {
    __asm__ volatile("wfi");
  }
}