main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_app.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_launch_hil_baud = 115200U, 
} app_launch_hil_t;

static const uint8_t k_app_launch_pass_banner[] = "app_launch_demo: demo PASS\r\n";

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

static void app_launch_hil_emit_pass(void)
{
  (void)ra8_board_uart_console_write(k_app_launch_pass_banner,
                                     (size_t)(sizeof(k_app_launch_pass_banner) - 1U));
  (void)ra8_board_uart_console_flush();
}

#ifndef APP_LAUNCH_SETTINGS
#define APP_LAUNCH_SETTINGS (1)
#endif

typedef enum : uint16_t {
  k_app_id_reader   = 1U, 
  k_app_id_settings = 2U, 
} app_launch_id_t;

typedef enum : uint16_t {
  k_app_reg_cap  = 2U, 
  k_app_nav_cap  = 4U, 
  k_app_btn_back = 1U, 
} app_launch_const_t;

typedef struct {
  const char* name;    
  uint32_t    enters;  
  uint32_t    leaves;  
  uint32_t    renders; 
  uint32_t    inputs;  
} app_launch_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_launch_ctx_t s_reader_ctx = {.name = "reader"};

static ra8_app_t s_reader_app;
 
#if APP_LAUNCH_SETTINGS
static app_launch_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 void app_stub_on_enter(ra8_app_t* a)
{
  app_launch_ctx_t* c = (app_launch_ctx_t*)a->ctx;
  c->enters++;
  ra8_log_info(c->name, "on_enter");
}

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

static void app_stub_render(const ra8_app_t* a)
{
  app_launch_ctx_t* c = (app_launch_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_launch_ctx_t* c = (app_launch_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 const ra8_app_vtable_t k_app_stub_vt = {
  .init     = nullptr,
  .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   = nullptr,
};
 
/* ===========================================================================
 * Registration + self-check (the "chrome")
 * ===========================================================================
 */

static bool app_launch_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;
  }
  s_reader_app = (ra8_app_t){.vt        = &k_app_stub_vt,
                             .ctx       = &s_reader_ctx,
                             .id        = (uint16_t)k_app_id_reader,
                             .name      = "reader",
                             .removable = false};
  bool ok      = (ra8_app_register(&s_reg, &s_reader_app) == k_ra8_ok);
#if APP_LAUNCH_SETTINGS
  s_settings_app = (ra8_app_t){.vt        = &k_app_stub_vt,
                               .ctx       = &s_settings_ctx,
                               .id        = (uint16_t)k_app_id_settings,
                               .name      = "settings",
                               .removable = true};
  if (ok) {
    ok = (ra8_app_register(&s_reg, &s_settings_app) == k_ra8_ok);
  }
#endif
  return ok;
}

static bool app_launch_enter_reader(void)
{
  uint16_t depth = 1U;
  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_reader_ctx.enters != 1U) {
    return false;
  }
  if (ra8_app_nav_depth(&s_nav, &depth) != k_ra8_ok) {
    return false;
  }
  return (depth == 0U);
}

static bool app_launch_route_back(void)
{
  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;
  }
  return (s_reader_ctx.inputs == 1U);
}
 
#if APP_LAUNCH_SETTINGS
static bool app_launch_switch_and_back(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 (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 != 1U) {
    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_launch_selfcheck(void)
{
  if (!app_launch_enter_reader()) {
    return false;
  }
  if (!app_launch_route_back()) {
    return false;
  }
#if APP_LAUNCH_SETTINGS
  if (!app_launch_switch_and_back()) {
    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_reader);
}

static void app_launch_banner(void)
{
  uint16_t n = 0U;
  (void)ra8_app_count(&s_reg, &n);
  (void)n; /* used only by the (level-gated) log lines below */
  ra8_log_info_val("app_launch", "apps", (uint32_t)n);
  ra8_log_info_val("app_launch", "reader enters", s_reader_ctx.enters);
  ra8_log_info("app_launch", "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_launch_hil_emit_pass();
}

void main(void)
{
  ra8_log_init();
  ra8_log_info("app_launch", "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_launch_hil_console_init()) {
    ra8_log_info("app_launch", "VCOM console init failed -- HIL banner unavailable");
  }
 
  bool ok = app_launch_register();
  if (!ok) {
    ra8_log_info("app_launch", "FAIL register");
  }
  if (ok) {
    ok = app_launch_selfcheck();
    if (!ok) {
      ra8_log_info("app_launch", "FAIL selfcheck");
    }
  }
  if (ok) {
    app_launch_banner();
  }
 
  while (1) {
    __asm__ volatile("wfi");
  }
}