main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_app.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_box.h"
#include "ra8_cgc.h"
#include "ra8_err.h"
#include "ra8_gfx.h"
#include "ra8_isr.h"
#include "ra8_mstp.h"
#include "ra8_time.h"
#include "ra8_ui.h"
#include "ra8_widget.h"

typedef enum : uint32_t {
  k_wa_uart_baud   = 115200U,     
  k_wa_fb_w        = 160U,        
  k_wa_fb_h        = 120U,        
  k_wa_statusbar_h = 16U,         
  k_wa_col_bg      = 0x101018U,   
  k_wa_col_status  = 0x808088U,   
  k_wa_col_library = 0x3050C0U,   
  k_wa_col_reader  = 0xC05030U,   
  k_wa_fnv_offset  = 0x811C9DC5U, 
  k_wa_fnv_prime   = 0x01000193U, 
  k_wa_hex_nibbles = 8U,          
  k_wa_nibble_bits = 4U,          
  k_wa_nibble_mask = 0x0FU,       
  k_wa_dec_ten     = 10U,         
} wa_consts_t;

typedef enum : uint16_t {
  k_wa_app_library = 1U, 
  k_wa_app_reader  = 2U, 
} wa_app_id_t;

static uint16_t s_framebuffer[(size_t)k_wa_fb_h * (size_t)k_wa_fb_w];

typedef struct {
  uint32_t color; 
} wa_fill_t;

typedef struct {
  ra8_widget_t widgets[2];   
  wa_fill_t    status_fill;  
  wa_fill_t    content_fill; 
  uint32_t     enters;       
  uint32_t     leaves;       
} wa_app_state_t;
 
static wa_app_state_t s_library;
static wa_app_state_t s_reader;
 
static const uint8_t k_msg_boot[]  = "widget-app-hil: boot\r\n";
static const uint8_t k_msg_fail[]  = "widget-app-hil: FAIL init\r\n";
static const uint8_t k_msg_freg[]  = "widget-app-hil: FAIL register\r\n";
static const uint8_t k_msg_fcrc[]  = "widget-app-hil: FAIL crc-equal\r\n";
static const uint8_t k_msg_flife[] = "widget-app-hil: FAIL lifecycle\r\n";
static const uint8_t k_msg_fdmg[]  = "widget-app-hil: FAIL damage\r\n";
static const uint8_t k_msg_pre[]   = "widget-app-hil: apps=2 lib=";
static const uint8_t k_msg_rdr[]   = " rdr=";
static const uint8_t k_msg_flush[] = " flush=160x16 hint=fast";
static const uint8_t k_msg_ok[]    = " PASS\r\n";

static void wa_print(const uint8_t* msg, uint32_t len)
{
  (void)ra8_board_uart_console_write(msg, (size_t)len);
}

static void wa_panic_halt(const uint8_t* msg, uint32_t len)
{
  wa_print(msg, len);
  __asm__ volatile("bkpt #0");
  while (1) {
    __asm__ volatile("wfi");
  }
}

static uint32_t wa_framebuffer_hash(void)
{
  const uint8_t* p   = (const uint8_t*)s_framebuffer;
  const size_t   n   = sizeof(s_framebuffer);
  uint32_t       hsh = (uint32_t)k_wa_fnv_offset;
  for (size_t i = 0U; i < n; i++) {
    hsh = (hsh ^ (uint32_t)p[i]) * (uint32_t)k_wa_fnv_prime;
  }
  return hsh;
}

static void wa_print_hex(uint32_t value)
{
  uint8_t buf[k_wa_hex_nibbles];
  for (uint32_t i = 0U; i < (uint32_t)k_wa_hex_nibbles; i++) {
    const uint32_t shift = ((uint32_t)k_wa_hex_nibbles - 1U - i) * (uint32_t)k_wa_nibble_bits;
    const uint32_t nib   = (value >> shift) & (uint32_t)k_wa_nibble_mask;
    buf[i] = (uint8_t)((nib < (uint32_t)k_wa_dec_ten) ? ('0' + nib) : ('A' + (nib - k_wa_dec_ten)));
  }
  wa_print(buf, (uint32_t)k_wa_hex_nibbles);
}

static void wa_fill_render(ra8_widget_t* w)
{
  const uint32_t color = ((const wa_fill_t*)w->ctx)->color;
  (void)ra8_gfx_rect(w->rect.x, w->rect.y, w->rect.w, w->rect.h, color, true);
}

static const ra8_widget_vtable_t k_wa_fill_vt = {
  .measure  = nullptr,
  .render   = wa_fill_render,
  .on_input = nullptr,
};

static void wa_state_init(wa_app_state_t* st, uint32_t content_color)
{
  st->status_fill.color  = (uint32_t)k_wa_col_status;
  st->content_fill.color = content_color;
  st->enters             = 0U;
  st->leaves             = 0U;
 
  st->widgets[0]         = (ra8_widget_t){};
  st->widgets[0].vt      = &k_wa_fill_vt;
  st->widgets[0].ctx     = &st->status_fill;
  st->widgets[0].fixed   = (int16_t)k_wa_statusbar_h;
  st->widgets[0].visible = true;
 
  st->widgets[1]         = (ra8_widget_t){};
  st->widgets[1].vt      = &k_wa_fill_vt;
  st->widgets[1].ctx     = &st->content_fill;
  st->widgets[1].flex    = 1U;
  st->widgets[1].visible = true;
}

static void wa_app_render(const ra8_app_t* a)
{
  wa_app_state_t*     st = (wa_app_state_t*)a->ctx;
  ra8_box_t           scratch[4];
  const ra8_ui_rect_t frame = {.x = 0, .y = 0, .w = (int32_t)k_wa_fb_w, .h = (int32_t)k_wa_fb_h};
  (void)ra8_gfx_clear((uint32_t)k_wa_col_bg);
  (void)ra8_widget_layout_stack(st->widgets, 2U, &frame, k_ra8_widget_axis_col, 0, 0, scratch, 4U);
  (void)ra8_widget_invalidate(&st->widgets[0], k_ra8_widget_refresh_quality);
  (void)ra8_widget_invalidate(&st->widgets[1], k_ra8_widget_refresh_quality);
  (void)ra8_widget_render_dirty(st->widgets, 2U);
}
 
static void wa_app_enter(ra8_app_t* a)
{
  ((wa_app_state_t*)a->ctx)->enters++;
}
 
static void wa_app_leave(ra8_app_t* a)
{
  ((wa_app_state_t*)a->ctx)->leaves++;
}

static const ra8_app_vtable_t k_wa_app_vt = {
  .init     = nullptr,
  .on_enter = wa_app_enter,
  .tick     = nullptr,
  .render   = wa_app_render,
  .on_input = nullptr,
  .on_leave = wa_app_leave,
  .deinit   = nullptr,
};

static void wa_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if ((ra8_cgc_init() != k_ra8_ok) || (ra8_mstp_init() != k_ra8_ok)) {
    wa_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    wa_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    wa_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if (ra8_board_uart_console_init((uint32_t)k_wa_uart_baud) != k_ra8_ok) {
    wa_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
}

static void wa_run_two_apps(ra8_app_registry_t* reg, uint32_t* out_lib, uint32_t* out_rdr)
{
  if (ra8_app_launch(reg, (uint16_t)k_wa_app_library) != k_ra8_ok) {
    wa_panic_halt(k_msg_freg, (uint32_t)sizeof(k_msg_freg) - 1U);
  }
  (void)ra8_app_render(reg);
  *out_lib = wa_framebuffer_hash();
 
  if (ra8_app_launch(reg, (uint16_t)k_wa_app_reader) != k_ra8_ok) {
    wa_panic_halt(k_msg_freg, (uint32_t)sizeof(k_msg_freg) - 1U);
  }
  (void)ra8_app_render(reg);
  *out_rdr = wa_framebuffer_hash();
}

static void wa_verify_or_halt(uint32_t lib_crc, uint32_t rdr_crc)
{
  /* The two app compositions must differ (different content widget). */
  if (lib_crc == rdr_crc) {
    wa_panic_halt(k_msg_fcrc, (uint32_t)sizeof(k_msg_fcrc) - 1U);
  }
  /* The focus lifecycle must have fired exactly once each. */
  if ((s_library.leaves != 1U) || (s_reader.enters != 1U) || (s_library.enters != 1U)) {
    wa_panic_halt(k_msg_flife, (uint32_t)sizeof(k_msg_flife) - 1U);
  }
  /* Partial-flush: invalidate ONLY the status bar -> damage is just its rect. */
  (void)ra8_widget_invalidate(&s_reader.widgets[0], k_ra8_widget_refresh_fast);
  ra8_ui_rect_t        dmg    = {};
  ra8_widget_refresh_t hint   = k_ra8_widget_refresh_none;
  uint16_t             ndirty = 0U;
  (void)ra8_widget_damage(s_reader.widgets, 2U, &dmg, &hint, &ndirty);
  if ((ndirty != 1U) || (dmg.h != (int32_t)k_wa_statusbar_h) || (dmg.y != 0) ||
      (dmg.w != (int32_t)k_wa_fb_w) || (hint != k_ra8_widget_refresh_fast)) {
    wa_panic_halt(k_msg_fdmg, (uint32_t)sizeof(k_msg_fdmg) - 1U);
  }
}

void main(void)
{
  wa_setup_or_halt();
  ra8_isr_globals_enable();
  wa_print(k_msg_boot, (uint32_t)sizeof(k_msg_boot) - 1U);
 
  if (ra8_gfx_init(s_framebuffer,
                   (uint16_t)k_wa_fb_w,
                   (uint16_t)k_wa_fb_h,
                   k_ra8_gfx_format_rgb565) != k_ra8_ok) {
    wa_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
 
  /* Two apps, each a widget tree. */
  wa_state_init(&s_library, (uint32_t)k_wa_col_library);
  wa_state_init(&s_reader, (uint32_t)k_wa_col_reader);
  ra8_app_t library = {.vt        = &k_wa_app_vt,
                       .ctx       = &s_library,
                       .id        = (uint16_t)k_wa_app_library,
                       .name      = "Library",
                       .removable = false};
  ra8_app_t reader  = {.vt        = &k_wa_app_vt,
                       .ctx       = &s_reader,
                       .id        = (uint16_t)k_wa_app_reader,
                       .name      = "Reader",
                       .removable = false};
 
  ra8_app_t*         slots[2];
  ra8_app_registry_t reg = {};
  if ((ra8_app_registry_init(&reg, slots, 2U) != k_ra8_ok) ||
      (ra8_app_register(&reg, &library) != k_ra8_ok) ||
      (ra8_app_register(&reg, &reader) != k_ra8_ok)) {
    wa_panic_halt(k_msg_freg, (uint32_t)sizeof(k_msg_freg) - 1U);
  }
 
  uint32_t lib_crc = 0U;
  uint32_t rdr_crc = 0U;
  wa_run_two_apps(&reg, &lib_crc, &rdr_crc);
  wa_verify_or_halt(lib_crc, rdr_crc);
 
  wa_print(k_msg_pre, (uint32_t)sizeof(k_msg_pre) - 1U);
  wa_print_hex(lib_crc);
  wa_print(k_msg_rdr, (uint32_t)sizeof(k_msg_rdr) - 1U);
  wa_print_hex(rdr_crc);
  wa_print(k_msg_flush, (uint32_t)sizeof(k_msg_flush) - 1U);
  wa_print(k_msg_ok, (uint32_t)sizeof(k_msg_ok) - 1U);
 
  while (1) {
    __asm__ volatile("wfi");
  }
}