main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_box.h"
#include "ra8_cgc.h"
#include "ra8_display_pal.h"
#include "ra8_display_pal_lcd.h"
#include "ra8_err.h"
#include "ra8_gfx.h"
#include "ra8_gfx_font.h"
#include "ra8_glcdc.h"
#include "ra8_isr.h"
#include "ra8_mstp.h"
#include "ra8_panel.h"
#include "ra8_panel_timing.h"
#include "ra8_time.h"
#include "ra8_ui.h"
#include "ra8_widget.h"

typedef enum : uint16_t {
  k_wc_fb_w     = 512U, 
  k_wc_fb_h     = 512U, 
  k_wc_status_h = 44U,  
  k_wc_footer_h = 28U,  
  k_wc_pad      = 8U,   
  k_wc_line_h   = 18U,  
  k_wc_tile_gap = 6U,   
} wc_geom_t;

typedef enum : uint32_t {
  k_wc_col_clear     = 0x000008U, 
  k_wc_col_status_bg = 0x1E2A40U, 
  k_wc_col_footer_bg = 0x14141AU, 
  k_wc_col_left_bg   = 0x102038U, 
  k_wc_col_right_bg  = 0x382414U, 
  k_wc_col_text      = 0xFFFFFFU, 
  k_wc_col_dim       = 0xA0A0B0U, 
} wc_color_t;

typedef enum : uint16_t {
  k_wc_w_status = 0U, 
  k_wc_w_body   = 1U, 
  k_wc_w_footer = 2U, 
  k_wc_root_n   = 3U, 
  k_wc_root_cap = 4U, 
  k_wc_w_left   = 0U, 
  k_wc_w_right  = 1U, 
  k_wc_body_n   = 2U, 
  k_wc_body_cap = 3U, 
} wc_widget_idx_t;

typedef enum : uint32_t {
  k_wc_uart_baud   = 115200U,     
  k_wc_frame_ms    = 500U,        
  k_wc_fnv_offset  = 2166136261U, 
  k_wc_fnv_prime   = 16777619U,   
  k_wc_hex_nibbles = 8U,          
  k_wc_nibble_bits = 4U,          
  k_wc_nibble_mask = 0x0FU,       
  k_wc_dec_ten     = 10U,         
  k_wc_frame_buf   = 24U,         
} wc_console_t;

[[gnu::aligned(k_ra8_board_fb_align_bytes)]] static uint16_t
  s_framebuffer[(uint32_t)k_wc_fb_w * (uint32_t)k_wc_fb_h];

typedef struct {
  uint32_t frame;   
  uint32_t renders; 
} wc_status_ctx_t;

typedef struct {
  const char* label;   
  uint32_t    bg;      
  uint32_t    renders; 
} wc_tile_ctx_t;
 
static wc_status_ctx_t s_status = {.frame = 0U, .renders = 0U};
static wc_tile_ctx_t   s_left   = {.label = "Left widget", .bg = (uint32_t)k_wc_col_left_bg};
static wc_tile_ctx_t   s_right  = {.label = "Right widget", .bg = (uint32_t)k_wc_col_right_bg};
 
static ra8_widget_t s_root_kids[k_wc_root_n];      
static ra8_widget_t s_body_kids[k_wc_body_n];      
static ra8_box_t    s_body_scratch[k_wc_body_cap]; 
static ra8_box_t    s_root_scratch[k_wc_root_cap]; 

static ra8_widget_panel_t s_body_panel = {.children    = s_body_kids,
                                          .box_scratch = s_body_scratch,
                                          .count       = (uint16_t)k_wc_body_n,
                                          .box_cap     = (uint16_t)k_wc_body_cap,
                                          .gap         = (int16_t)k_wc_tile_gap,
                                          .pad         = 0,
                                          .axis        = k_ra8_widget_axis_row,
                                          .reserved    = 0U};

static ra8_widget_panel_t s_root_panel = {.children    = s_root_kids,
                                          .box_scratch = s_root_scratch,
                                          .count       = (uint16_t)k_wc_root_n,
                                          .box_cap     = (uint16_t)k_wc_root_cap,
                                          .gap         = 0,
                                          .pad         = 0,
                                          .axis        = k_ra8_widget_axis_col,
                                          .reserved    = 0U};

static ra8_widget_t s_root;
static display_handle_t* s_display = nullptr;
 
static const uint8_t k_wc_msg_boot[]  = "widget-compose-demo: boot\r\n";
static const uint8_t k_wc_msg_finit[] = "widget-compose-demo: FAIL init\r\n";
static const uint8_t k_wc_msg_fpanl[] = "widget-compose-demo: FAIL panel\r\n";
static const uint8_t k_wc_msg_ftree[] = "widget-compose-demo: FAIL tree\r\n";
static const uint8_t k_wc_msg_fchk[]  = "widget-compose-demo: FAIL selfcheck\r\n";
static const uint8_t k_wc_msg_pre[]   = "widget-compose-demo: dirty0=";
static const uint8_t k_wc_msg_crc0[]  = " crc0=";
static const uint8_t k_wc_msg_d1[]    = " dirty1=";
static const uint8_t k_wc_msg_crc1[]  = " crc1=";
static const uint8_t k_wc_msg_tail[]  = " flush=512x44 hint=fast";
static const uint8_t k_wc_msg_pass[]  = " PASS\r\n";
 
/* ===========================================================================
 * Console
 * ===========================================================================
 */

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

static void wc_fail_halt(const uint8_t* msg, uint32_t len)
{
  wc_print(msg, len);
  while (1) {
    __asm__ volatile("wfi");
  }
}

static void wc_print_hex(uint32_t value)
{
  uint8_t buf[k_wc_hex_nibbles];
  for (uint32_t i = 0U; i < (uint32_t)k_wc_hex_nibbles; i++) {
    const uint32_t shift = ((uint32_t)k_wc_hex_nibbles - 1U - i) * (uint32_t)k_wc_nibble_bits;
    const uint32_t nib   = (value >> shift) & (uint32_t)k_wc_nibble_mask;
    buf[i] = (uint8_t)((nib < (uint32_t)k_wc_dec_ten) ? ('0' + nib) : ('A' + (nib - k_wc_dec_ten)));
  }
  wc_print(buf, (uint32_t)k_wc_hex_nibbles);
}

static void wc_print_uint(uint32_t value)
{
  uint8_t  buf[k_wc_dec_ten];
  uint32_t n = 0U;
  if (value == 0U) {
    buf[n] = '0';
    n++;
  }
  while ((value > 0U) && (n < (uint32_t)k_wc_dec_ten)) {
    buf[n] = (uint8_t)('0' + (value % (uint32_t)k_wc_dec_ten));
    n++;
    value /= (uint32_t)k_wc_dec_ten;
  }
  for (uint32_t i = 0U; i < n; i++) {
    wc_print(&buf[n - 1U - i], 1U);
  }
}

static uint32_t wc_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_wc_fnv_offset;
  for (size_t i = 0U; i < n; i++) {
    hsh = (hsh ^ (uint32_t)p[i]) * (uint32_t)k_wc_fnv_prime;
  }
  return hsh;
}
 
/* ===========================================================================
 * Widget renderers
 * ===========================================================================
 */

static void wc_fmt_frame(char* buf, uint32_t frame)
{
  static const char prefix[] = "frame=";
  uint32_t          pos      = 0U;
  for (uint32_t i = 0U; i < (uint32_t)(sizeof(prefix) - 1U); i++) {
    buf[pos] = prefix[i];
    pos++;
  }
  char     digits[k_wc_dec_ten];
  uint32_t n = 0U;
  if (frame == 0U) {
    digits[n] = '0';
    n++;
  }
  while ((frame > 0U) && (n < (uint32_t)k_wc_dec_ten)) {
    digits[n] = (char)('0' + (frame % (uint32_t)k_wc_dec_ten));
    n++;
    frame /= (uint32_t)k_wc_dec_ten;
  }
  for (uint32_t i = 0U; i < n; i++) {
    buf[pos] = digits[n - 1U - i];
    pos++;
  }
  buf[pos] = '\0';
}

static void wc_status_render(ra8_widget_t* w)
{
  wc_status_ctx_t* st = (wc_status_ctx_t*)w->ctx;
  st->renders++;
  char frame_str[k_wc_frame_buf];
  wc_fmt_frame(frame_str, st->frame);
  (void)
    ra8_gfx_rect(w->rect.x, w->rect.y, w->rect.w, w->rect.h, (uint32_t)k_wc_col_status_bg, true);
  const int32_t tx = w->rect.x + (int32_t)k_wc_pad;
  (void)ra8_gfx_text_out(tx,
                         w->rect.y + (int32_t)k_wc_pad,
                         "widget-compose-demo  status bar",
                         &ra8_gfx_font_8x16,
                         (uint32_t)k_wc_col_text,
                         (uint32_t)k_wc_col_status_bg);
  (void)ra8_gfx_text_out(tx,
                         w->rect.y + (int32_t)k_wc_pad + (int32_t)k_wc_line_h,
                         frame_str,
                         &ra8_gfx_font_8x16,
                         (uint32_t)k_wc_col_dim,
                         (uint32_t)k_wc_col_status_bg);
}

static void wc_tile_render(ra8_widget_t* w)
{
  wc_tile_ctx_t* t = (wc_tile_ctx_t*)w->ctx;
  t->renders++;
  (void)ra8_gfx_rect(w->rect.x, w->rect.y, w->rect.w, w->rect.h, t->bg, true);
  const int32_t tx = w->rect.x + (int32_t)k_wc_pad;
  (void)ra8_gfx_text_out(tx,
                         w->rect.y + (int32_t)k_wc_pad,
                         t->label,
                         &ra8_gfx_font_8x16,
                         (uint32_t)k_wc_col_text,
                         t->bg);
  (void)ra8_gfx_text_out(tx,
                         w->rect.y + (int32_t)k_wc_pad + (int32_t)k_wc_line_h +
                           (int32_t)k_wc_line_h,
                         "nested in the body panel",
                         &ra8_gfx_font_8x16,
                         (uint32_t)k_wc_col_dim,
                         t->bg);
}

static void wc_footer_render(ra8_widget_t* w)
{
  (void)w->ctx;
  (void)
    ra8_gfx_rect(w->rect.x, w->rect.y, w->rect.w, w->rect.h, (uint32_t)k_wc_col_footer_bg, true);
  (void)ra8_gfx_text_out(w->rect.x + (int32_t)k_wc_pad,
                         w->rect.y + ((int32_t)k_wc_footer_h / 4),
                         "ra8_widget_panel: nested tree, damage-tracked flush",
                         &ra8_gfx_font_8x16,
                         (uint32_t)k_wc_col_dim,
                         (uint32_t)k_wc_col_footer_bg);
}

static const ra8_widget_vtable_t k_wc_status_vt = {.measure  = nullptr,
                                                   .render   = wc_status_render,
                                                   .on_input = nullptr};
static const ra8_widget_vtable_t k_wc_tile_vt   = {.measure  = nullptr,
                                                   .render   = wc_tile_render,
                                                   .on_input = nullptr};
static const ra8_widget_vtable_t k_wc_footer_vt = {.measure  = nullptr,
                                                   .render   = wc_footer_render,
                                                   .on_input = nullptr};
 
/* ===========================================================================
 * Tree assembly + compose
 * ===========================================================================
 */

static void wc_leaf_init(ra8_widget_t*              w,
                         const ra8_widget_vtable_t* vt,
                         void*                      ctx,
                         int16_t                    fixed,
                         uint16_t                   flex)
{
  *w         = (ra8_widget_t){};
  w->vt      = vt;
  w->ctx     = ctx;
  w->fixed   = fixed;
  w->flex    = flex;
  w->visible = true;
}

static bool wc_build_tree(void)
{
  wc_leaf_init(&s_body_kids[k_wc_w_left], &k_wc_tile_vt, &s_left, 0, 1U);
  wc_leaf_init(&s_body_kids[k_wc_w_right], &k_wc_tile_vt, &s_right, 0, 1U);
  wc_leaf_init(&s_root_kids[k_wc_w_status], &k_wc_status_vt, &s_status, (int16_t)k_wc_status_h, 0U);
  wc_leaf_init(&s_root_kids[k_wc_w_footer], &k_wc_footer_vt, nullptr, (int16_t)k_wc_footer_h, 0U);
 
  /* The body child is itself a panel -- the nesting the new primitive adds. */
  if (ra8_widget_panel_init(&s_root_kids[k_wc_w_body], &s_body_panel) != k_ra8_ok) {
    return false;
  }
  s_root_kids[k_wc_w_body].flex = 1U;
  return (ra8_widget_panel_init(&s_root, &s_root_panel) == k_ra8_ok);
}

static void wc_invalidate_all(ra8_widget_refresh_t refresh)
{
  for (uint16_t i = 0U; i < (uint16_t)k_wc_root_n; i++) {
    (void)ra8_widget_invalidate(&s_root_kids[i], refresh);
  }
}

static ra8_err_t wc_compose(ra8_ui_rect_t* dmg, ra8_widget_refresh_t* hint, uint16_t* dirty)
{
  const ra8_ui_rect_t frame = {.x = 0, .y = 0, .w = (int32_t)k_wc_fb_w, .h = (int32_t)k_wc_fb_h};
  return ra8_widget_panel_compose(&s_root, &frame, dmg, hint, dirty);
}
 
/* ===========================================================================
 * GLCDC panel bring-up + flush
 * ===========================================================================
 */

static const display_cfg_t k_wc_display_cfg = {
  .iface             = &k_display_backend_lcd_ra8_glcdc,
  .framebuffer       = s_framebuffer,
  .framebuffer_bytes = sizeof(s_framebuffer),
  .width_px          = (uint16_t)k_wc_fb_w,
  .height_px         = (uint16_t)k_wc_fb_h,
  .pixfmt            = k_display_pixfmt_rgb565,
  .panel_timing      = &s_ra8_panel_ek_ra8d2_timing,
};

static bool wc_panel_up(void)
{
  if (display_init(&k_wc_display_cfg, &s_display) != k_ra8_ok) {
    return false;
  }
  if (s_display == nullptr) {
    return false;
  }
  display_fb_t fb = {};
  if (display_get_framebuffer(s_display, &fb) != k_ra8_ok) {
    return false;
  }
  if (fb.pixels != (void*)s_framebuffer) {
    return false;
  }
  return (ra8_gfx_init(s_framebuffer,
                       (uint16_t)k_wc_fb_w,
                       (uint16_t)k_wc_fb_h,
                       k_ra8_gfx_format_rgb565) == k_ra8_ok);
}

static display_refresh_hint_t wc_map_hint(ra8_widget_refresh_t hint)
{
  if (hint == k_ra8_widget_refresh_fast) {
    return k_display_refresh_fast;
  }
  return k_display_refresh_quality;
}

static void wc_flush_rect(const ra8_ui_rect_t* dmg, ra8_widget_refresh_t hint)
{
  if (s_display == nullptr) {
    return;
  }
  if ((dmg->w <= 0) || (dmg->h <= 0)) {
    return;
  }
  const display_rect_t r = {.x = (uint16_t)dmg->x,
                            .y = (uint16_t)dmg->y,
                            .w = (uint16_t)dmg->w,
                            .h = (uint16_t)dmg->h};
  (void)display_flush(s_display, r, wc_map_hint(hint));
}
 
/* ===========================================================================
 * Deterministic self-check
 * ===========================================================================
 */

static bool wc_check_full(uint32_t* out_crc, uint16_t* out_dirty)
{
  s_left.renders  = 0U;
  s_right.renders = 0U;
  wc_invalidate_all(k_ra8_widget_refresh_quality);
  ra8_ui_rect_t        dmg  = {};
  ra8_widget_refresh_t hint = k_ra8_widget_refresh_none;
  uint16_t             nd   = 0U;
  if (wc_compose(&dmg, &hint, &nd) != k_ra8_ok) {
    return false;
  }
  if (nd != (uint16_t)k_wc_root_n) {
    return false;
  }
  if ((dmg.w != (int32_t)k_wc_fb_w) || (dmg.h != (int32_t)k_wc_fb_h)) {
    return false;
  }
  if (hint != k_ra8_widget_refresh_quality) {
    return false;
  }
  if ((s_left.renders != 1U) || (s_right.renders != 1U)) {
    return false; /* nested body panel must have composited both tiles */
  }
  *out_crc   = wc_framebuffer_hash();
  *out_dirty = nd;
  return true;
}

static bool wc_check_partial(uint32_t* out_crc, uint16_t* out_dirty)
{
  s_left.renders  = 0U;
  s_right.renders = 0U;
  s_status.frame++;
  (void)ra8_widget_invalidate(&s_root_kids[k_wc_w_status], k_ra8_widget_refresh_fast);
  ra8_ui_rect_t        dmg  = {};
  ra8_widget_refresh_t hint = k_ra8_widget_refresh_none;
  uint16_t             nd   = 0U;
  if (wc_compose(&dmg, &hint, &nd) != k_ra8_ok) {
    return false;
  }
  if (nd != 1U) {
    return false;
  }
  if ((dmg.x != 0) || (dmg.y != 0) || (dmg.w != (int32_t)k_wc_fb_w)) {
    return false;
  }
  if (dmg.h != (int32_t)k_wc_status_h) {
    return false;
  }
  if (hint != k_ra8_widget_refresh_fast) {
    return false;
  }
  if ((s_left.renders != 0U) || (s_right.renders != 0U)) {
    return false; /* partial flush must NOT re-render the body */
  }
  *out_crc   = wc_framebuffer_hash();
  *out_dirty = nd;
  return true;
}

static bool wc_selfcheck(uint32_t* crc0, uint16_t* d0, uint32_t* crc1, uint16_t* d1)
{
  if (!wc_check_full(crc0, d0)) {
    return false;
  }
  if (!wc_check_partial(crc1, d1)) {
    return false;
  }
  return (*crc0 != *crc1); /* the advanced frame counter changes the composite */
}
 
/* ===========================================================================
 * Boot
 * ===========================================================================
 */

static void wc_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if ((ra8_cgc_init() != k_ra8_ok) || (ra8_mstp_init() != k_ra8_ok)) {
    wc_fail_halt(k_wc_msg_finit, (uint32_t)sizeof(k_wc_msg_finit) - 1U);
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    wc_fail_halt(k_wc_msg_finit, (uint32_t)sizeof(k_wc_msg_finit) - 1U);
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    wc_fail_halt(k_wc_msg_finit, (uint32_t)sizeof(k_wc_msg_finit) - 1U);
  }
  if (ra8_board_uart_console_init((uint32_t)k_wc_uart_baud) != k_ra8_ok) {
    wc_fail_halt(k_wc_msg_finit, (uint32_t)sizeof(k_wc_msg_finit) - 1U);
  }
}

static void wc_print_banner(uint16_t d0, uint32_t crc0, uint16_t d1, uint32_t crc1)
{
  wc_print(k_wc_msg_pre, (uint32_t)sizeof(k_wc_msg_pre) - 1U);
  wc_print_uint((uint32_t)d0);
  wc_print(k_wc_msg_crc0, (uint32_t)sizeof(k_wc_msg_crc0) - 1U);
  wc_print_hex(crc0);
  wc_print(k_wc_msg_d1, (uint32_t)sizeof(k_wc_msg_d1) - 1U);
  wc_print_uint((uint32_t)d1);
  wc_print(k_wc_msg_crc1, (uint32_t)sizeof(k_wc_msg_crc1) - 1U);
  wc_print_hex(crc1);
  wc_print(k_wc_msg_tail, (uint32_t)sizeof(k_wc_msg_tail) - 1U);
  wc_print(k_wc_msg_pass, (uint32_t)sizeof(k_wc_msg_pass) - 1U);
}

static void wc_tick_live(void)
{
  s_status.frame++;
  (void)ra8_widget_invalidate(&s_root_kids[k_wc_w_status], k_ra8_widget_refresh_fast);
  ra8_ui_rect_t        dmg  = {};
  ra8_widget_refresh_t hint = k_ra8_widget_refresh_none;
  uint16_t             nd   = 0U;
  if (wc_compose(&dmg, &hint, &nd) == k_ra8_ok) {
    wc_flush_rect(&dmg, hint);
  }
}

void main(void)
{
  wc_setup_or_halt();
  ra8_isr_globals_enable();
  wc_print(k_wc_msg_boot, (uint32_t)sizeof(k_wc_msg_boot) - 1U);
 
  if (!wc_panel_up()) {
    wc_fail_halt(k_wc_msg_fpanl, (uint32_t)sizeof(k_wc_msg_fpanl) - 1U);
  }
  if (!wc_build_tree()) {
    wc_fail_halt(k_wc_msg_ftree, (uint32_t)sizeof(k_wc_msg_ftree) - 1U);
  }
 
  uint32_t crc0 = 0U;
  uint32_t crc1 = 0U;
  uint16_t d0   = 0U;
  uint16_t d1   = 0U;
  if (!wc_selfcheck(&crc0, &d0, &crc1, &d1)) {
    wc_fail_halt(k_wc_msg_fchk, (uint32_t)sizeof(k_wc_msg_fchk) - 1U);
  }
  wc_print_banner(d0, crc0, d1, crc1);
 
  /* Land on a full composite and show it live on the panel. */
  (void)ra8_gfx_clear((uint32_t)k_wc_col_clear);
  wc_invalidate_all(k_ra8_widget_refresh_quality);
  ra8_ui_rect_t        dmg  = {};
  ra8_widget_refresh_t hint = k_ra8_widget_refresh_none;
  uint16_t             nd   = 0U;
  if (wc_compose(&dmg, &hint, &nd) == k_ra8_ok) {
    wc_flush_rect(&dmg, hint);
  }
 
  while (1) {
    wc_tick_live();
    ra8_delay_ms((uint32_t)k_wc_frame_ms);
  }
}