main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "ez_scene.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_board_ek_ra8d2_touch.h"
#include "ra8_boot_entry.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_isr.h"
#include "ra8_mstp.h"
#include "ra8_panel.h"
#include "ra8_panel_timing.h"
#include "ra8_sdramc.h"
#include "ra8_time.h"
#include "ra8_touch.h"

typedef enum : uint32_t {
  k_ez_uart_baud        = 115200U, 
  k_ez_settle_ms        = 500U,    
  k_ez_frame_ms         = 25U,     
  k_ez_led_every        = 16U,     
  k_ez_touch_max_points = 1U,      
} ez_boot_t;

typedef enum : uint16_t {
  k_ez_fb_w = k_panel_width_px,  
  k_ez_fb_h = k_panel_height_px, 
} ez_fb_t;

typedef enum : uint8_t {
  k_ez_hex_nibbles = 8U,    
  k_ez_nibble_bits = 4U,    
  k_ez_nibble_mask = 0x0FU, 
  k_ez_dec_ten     = 10U,   
} ez_print_t;

RA8_BOARD_PANEL_FRAMEBUFFER(s_framebuffer);

[[gnu::section(
  ".sdram_data")]] static uint8_t s_cell_mem[(size_t)k_ez_cells * (size_t)k_ez_cell_bytes];

static ra8_keycache_cell_t s_meta[k_ez_cells];

static ra8_tile_key_t s_keys[k_ez_cells];

static ra8_tile_dims_t s_dims[k_ez_cells];

static int32_t s_buckets[k_ez_buckets];

static uint8_t s_row[k_ez_row_bytes];

static uint8_t s_strip[k_ez_strip_bytes];

static uint8_t s_packed[k_ez_packed_bytes];

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

static display_handle_t* s_display = nullptr;

static display_fb_t s_fb;

static ez_scene_t s_scene;

static const uint8_t k_msg_boot[] = "ereader-zoom: boot\r\n";
static const uint8_t k_msg_fail[] = "ereader-zoom: FAIL init\r\n";
static const uint8_t k_msg_scene[] = "ereader-zoom: FAIL scene\r\n";
static const uint8_t k_msg_rend[] = "ereader-zoom: FAIL render\r\n";
static const uint8_t k_msg_pre[] = "ereader-zoom: page ";
static const uint8_t k_msg_x[] = "x";
static const uint8_t k_msg_tile[] = " tile ";
static const uint8_t k_msg_cells[] = " cells ";
static const uint8_t k_msg_z1[] = " z1=";
static const uint8_t k_msg_pan[] = " pan=";
static const uint8_t k_msg_z2[] = " z2=";
static const uint8_t k_msg_lens[] = " lens=";
static const uint8_t k_msg_hit[] = " hit=";
static const uint8_t k_msg_miss[] = " miss=";
static const uint8_t k_msg_evict[] = " evict=";
static const uint8_t k_msg_warm[] = " warm=";
static const uint8_t k_msg_ok[] = " ok\r\n";

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

static void ez_panic_halt(const uint8_t* msg, uint32_t len)
{
  ez_print(msg, len);
  (void)ra8_board_led_on(k_ra8_board_led_red);
  __asm__ volatile("bkpt #0");
  while (1) {
    __asm__ volatile("wfi");
  }
}

static void ez_print_hex(uint32_t value)
{
  uint8_t buf[k_ez_hex_nibbles];
  for (uint32_t i = 0U; i < (uint32_t)k_ez_hex_nibbles; ++i) {
    const uint32_t shift = ((uint32_t)k_ez_hex_nibbles - 1U - i) * (uint32_t)k_ez_nibble_bits;
    const uint32_t nib   = (value >> shift) & (uint32_t)k_ez_nibble_mask;
    buf[i] = (uint8_t)((nib < (uint32_t)k_ez_dec_ten) ? ('0' + nib) : ('A' + (nib - k_ez_dec_ten)));
  }
  ez_print(buf, (uint32_t)k_ez_hex_nibbles);
}

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

static void ez_bringup_clocks(void)
{
  uint32_t cpuclk0_hz = 0U;
  if ((ra8_cgc_init() != k_ra8_ok) || (ra8_mstp_init() != k_ra8_ok)) {
    ez_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) {
    ez_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    ez_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if ((ra8_board_led_init(k_ra8_board_led_blue) != k_ra8_ok) ||
      (ra8_board_led_init(k_ra8_board_led_red) != k_ra8_ok)) {
    ez_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if (ra8_board_uart_console_init((uint32_t)k_ez_uart_baud) != k_ra8_ok) {
    ez_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  ra8_isr_globals_enable();
}

static void ez_bringup_panel(void)
{
  ra8_delay_ms((uint32_t)k_ez_settle_ms);
  if (ra8_sdramc_init() != k_ra8_ok) {
    ez_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if (display_init(&k_ez_display_cfg, &s_display) != k_ra8_ok) {
    ez_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if (display_get_framebuffer(s_display, &s_fb) != k_ra8_ok) {
    ez_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if (ra8_gfx_init(s_fb.pixels, s_fb.width_px, s_fb.height_px, k_ra8_gfx_format_rgb565) !=
      k_ra8_ok) {
    ez_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
}

static void ez_bringup_touch(void)
{
  const ra8_board_touch_cfg_t cfg = {.max_points = (uint8_t)k_ez_touch_max_points,
                                     .irq_pin    = (uint8_t)k_ra8_touch_irq_pin_unset};
  (void)ra8_board_touch_open(&cfg);
}

static void ez_flush(const ez_present_t* plan)
{
  const display_rect_t rect = {
    .x = (uint16_t)plan->rect.x,
    .y = (uint16_t)plan->rect.y,
    .w = (uint16_t)plan->rect.w,
    .h = (uint16_t)plan->rect.h,
  };
  /* The engine's fast/quality split IS the e-ink waveform choice: a pan burst
   * flushes A2 (bi-level, ~10x faster than GC16) and the settle repaints the
   * same rectangle in all 16 levels. On this GLCDC panel the hint is inert;
   * the e-ink backend honours it. */
  (void)display_flush(s_display,
                      rect,
                      plan->quality ? k_display_refresh_quality : k_display_refresh_fast);
}

static bool ez_redraw(void)
{
  if (ez_scene_render(&s_scene) != k_ra8_ok) {
    return false;
  }
  ez_present_t plan = {};
  if (ez_scene_present(&s_scene, &plan) != k_ra8_ok) {
    return false;
  }
  if (plan.present) {
    ez_flush(&plan);
  }
  return true;
}

static void ez_print_banner(const ez_selftest_t* st)
{
  ez_print(k_msg_pre, (uint32_t)sizeof(k_msg_pre) - 1U);
  ez_print_uint((uint32_t)k_ez_page_w);
  ez_print(k_msg_x, (uint32_t)sizeof(k_msg_x) - 1U);
  ez_print_uint((uint32_t)k_ez_page_h);
  ez_print(k_msg_tile, (uint32_t)sizeof(k_msg_tile) - 1U);
  ez_print_uint((uint32_t)k_ez_tile_edge);
  ez_print(k_msg_cells, (uint32_t)sizeof(k_msg_cells) - 1U);
  ez_print_uint((uint32_t)k_ez_cells);
  ez_print(k_msg_z1, (uint32_t)sizeof(k_msg_z1) - 1U);
  ez_print_hex(st->crc_1x);
  ez_print(k_msg_pan, (uint32_t)sizeof(k_msg_pan) - 1U);
  ez_print_hex(st->crc_pan);
  ez_print(k_msg_z2, (uint32_t)sizeof(k_msg_z2) - 1U);
  ez_print_hex(st->crc_2x);
  ez_print(k_msg_lens, (uint32_t)sizeof(k_msg_lens) - 1U);
  ez_print_hex(st->crc_lens);
  ez_print(k_msg_hit, (uint32_t)sizeof(k_msg_hit) - 1U);
  ez_print_uint(st->hits);
  ez_print(k_msg_miss, (uint32_t)sizeof(k_msg_miss) - 1U);
  ez_print_uint(st->misses);
  ez_print(k_msg_evict, (uint32_t)sizeof(k_msg_evict) - 1U);
  ez_print_uint(st->evictions);
  ez_print(k_msg_warm, (uint32_t)sizeof(k_msg_warm) - 1U);
  ez_print_uint((uint32_t)st->warmed);
  ez_print(k_msg_ok, (uint32_t)sizeof(k_msg_ok) - 1U);
}

static void ez_poll_touch(bool* was_touching)
{
  ra8_touch_point_t pt  = {};
  uint8_t           got = 0U;
  if (ra8_touch_read(&pt, 1U, &got) != k_ra8_ok) {
    return;
  }
  const bool touching = (got > 0U);
  if (touching && !(*was_touching)) {
    if (ez_scene_tap(&s_scene, (int32_t)pt.x, (int32_t)pt.y, ra8_time_ms())) {
      (void)ez_redraw();
    }
  }
  *was_touching = touching;
}

static bool ez_setup_scene(void)
{
  const ez_scene_cfg_t cfg = {
    .fb       = s_framebuffer,
    .fb_bytes = (uint32_t)sizeof(s_framebuffer),
    .fb_w     = (int32_t)k_ez_fb_w,
    .fb_h     = (int32_t)k_ez_fb_h,
    .cell_mem = s_cell_mem,
    .meta     = s_meta,
    .keys     = s_keys,
    .dims     = s_dims,
    .buckets  = s_buckets,
    .row      = s_row,
    .strip    = s_strip,
    .packed   = s_packed,
  };
  return ez_scene_init(&s_scene, &cfg) == k_ra8_ok;
}

void main(void)
{
  ez_bringup_clocks();
  ez_print(k_msg_boot, (uint32_t)sizeof(k_msg_boot) - 1U);
  ez_bringup_panel();
  ez_bringup_touch();
 
  if (!ez_setup_scene()) {
    ez_panic_halt(k_msg_scene, (uint32_t)sizeof(k_msg_scene) - 1U);
  }
 
  ez_selftest_t st = {};
  if (ez_scene_selftest(&s_scene, &st) != k_ra8_ok) {
    ez_panic_halt(k_msg_rend, (uint32_t)sizeof(k_msg_rend) - 1U);
  }
  /* The self-check consumed every pending plan, so publish its final frame
   * explicitly: one clean full-quality flush of the content area. */
  const ez_present_t final_plan = {
    .rect    = ez_content_rect((int32_t)k_ez_fb_w, (int32_t)k_ez_fb_h),
    .quality = true,
    .present = true,
  };
  ez_flush(&final_plan);
  ez_print_banner(&st);
 
  bool     was_touching = false;
  uint32_t ticks        = 0U;
  while (1) {
    ez_poll_touch(&was_touching);
    /* Settle promotion: once a gesture burst has been still for the view's
     * settle window, repaint the same rectangle at full 16-level quality. */
    if (ez_scene_tick(&s_scene, ra8_time_ms())) {
      (void)ez_redraw();
    }
    if ((ticks % (uint32_t)k_ez_led_every) == 0U) {
      (void)ra8_board_led_toggle(k_ra8_board_led_blue);
    }
    ticks++;
    ra8_delay_ms((uint32_t)k_ez_frame_ms);
  }
}