ra8-firmware/examples_2ek__ra8d2_2hw__validated_2hil_2ereader__ui_2src_2main_8c_source.html

#include <stddef.h>

#include <stdint.h>

#include <string.h>


#include "er_pageturn.h"

#include "ereader_ui_steps.h"

#include "literata_latin1.h"

#include "ra8_app.h"

#include "ra8_batt.h"

#include "ra8_board_ek_ra8d2.h"

#include "ra8_board_ek_ra8d2_touch.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_display_pal_policy.h"

#include "ra8_err.h"

#include "ra8_gfx.h"

#include "ra8_isr.h"

#include "ra8_mstp.h"

#include "ra8_panel_timing.h"

#include "ra8_port_constants.h"

#include "ra8_port_utils.h"

#include "ra8_sdfont.h"

#include "ra8_sdramc.h"

#include "ra8_time.h"

#include "ra8_touch.h"

#include "ra8_ui.h"

#include "reflow.h"


/* ===========================================================================

 * Static content (ASCII; public-domain titles)

 *

 * Defined here (single definition site) and shared with the helper translation

 * units through the ``extern`` declarations in ereader_ui_steps.h.

 * =========================================================================== */


const char k_er_wordmark[6] = "PAPYR";

static_assert(sizeof(k_er_wordmark) == 6U, "k_er_wordmark size pins the er_read_sb_render advance");

const char k_er_lib_heading[]  = "PAPYR   Library";

const char k_er_status_right[] = "10:24   98%";

const char k_er_search_hint[]  = "Search";

const char k_er_count_text[]   = "6 books";

const char k_er_book_title[]   = "The Time Machine";

const char k_er_page_label[]   = "Page 12 of 248";

const char k_er_chapter[]      = "I";


const char* const k_er_nav_items[] = {"Library", "Store", "Notes", "Settings"};

static_assert((sizeof(k_er_nav_items) / sizeof(k_er_nav_items[0])) == (size_t)k_er_nav_count,

              "k_er_nav_count must match k_er_nav_items");


const er_book_t k_er_books[] = {

  {"The Time Machine", "H. G. Wells", 5U},

  {"Frankenstein", "Mary Shelley", 100U},

  {"Pride and Prejudice", "Jane Austen", 42U},

  {"Moby-Dick", "Herman Melville", 12U},

  {"The Republic", "Plato", 68U},

  {"Meditations", "M. Aurelius", 30U},

};


static_assert((sizeof(k_er_books) / sizeof(k_er_books[0])) == (size_t)k_er_book_count,

              "k_er_book_count must match k_er_books");


const char* const k_er_body_lines[] = {

  "The Time Traveller (for so it will be convenient to speak of him)",

  "was expounding a recondite matter to us. His pale grey eyes shone",

  "and twinkled, and his usually pale face was flushed and animated.",

  "",

  "The fire burnt brightly, and the soft radiance of the incandescent",

  "lights in the lilies of silver caught the bubbles that flashed and",

  "passed in our glasses. Our chairs, being his patents, embraced and",

  "caressed us rather than submitted to be sat upon -- there was that",

  "luxurious after-dinner atmosphere when thought roams gracefully free",

  "of the trammels of precision.",

};


static_assert((sizeof(k_er_body_lines) / sizeof(k_er_body_lines[0])) ==

                (size_t)k_er_body_line_count,

              "k_er_body_line_count must match k_er_body_lines");


static const char k_er_chapter_xhtml[] =

  "<html><head><style>h1 { text-align: center; color: maroon; }"

  ".byline { text-align: right; text-decoration: underline; color: #808080; font-size: 14px; }"

  ".lead { font-size: 130%; } .draft { display: none; }"

  " p.lead { color: navy; }</style></head>"

  "<body><h1>The Time Machine</h1>"

  "<p class=\"draft\">INTERNAL DRAFT -- NOT FOR DISTRIBUTION</p>"

  "<p class=\"byline\">by H. G. Wells</p>"

  "<img src=\"logo.svg\"/>"

  "<p class=\"lead\">The Time Traveller (for so it will be convenient to speak of him) was "

  "expounding a recondite matter to us. See the "

  "<a href=\"#note\">editor's note</a> for context. His pale grey eyes shone "

  "and twinkled, and his usually pale face was flushed and animated.</p>"

  "<p>The fire burnt brightly, and the soft radiance of the incandescent lights "

  "in the lilies of silver caught the bubbles that flashed and passed in our "

  "glasses. Our chairs, being his patents, embraced and caressed us rather than "

  "submitted to be sat upon, and thought roamed gracefully free of the trammels "

  "of precision.</p>"

  "<p id=\"note\">Editor's note: this passage introduces the frame narrator "

  "before the Traveller's account begins. <a href=\"ch2.xhtml\">Continue to "

  "Chapter II</a>.</p></body></html>";


static const char k_er_chapter2_xhtml[] =

  "<html><body><h1>Chapter II</h1>"

  "<p>The Machine, said the Time Traveller, holding the lamp aloft, is the thing "

  "I have been at work upon these many years; and now at last it is built.</p>"

  "<p>He took one of the small octahedral things from the table and handed it to "

  "us. <a href=\"ch1.xhtml\">Back to Chapter I</a>.</p></body></html>";


const er_chapter_t k_er_spine[] = {

  {k_er_chapter_xhtml,

   (uint32_t)(sizeof(k_er_chapter_xhtml) - 1U),

   "ch1.xhtml",

   (uint32_t)(sizeof("ch1.xhtml") - 1U)},

  {k_er_chapter2_xhtml,

   (uint32_t)(sizeof(k_er_chapter2_xhtml) - 1U),

   "ch2.xhtml",

   (uint32_t)(sizeof("ch2.xhtml") - 1U)},

};


static_assert((sizeof(k_er_spine) / sizeof(k_er_spine[0])) == (size_t)k_er_spine_count,

              "k_er_spine_count must match k_er_spine");


uint32_t s_chapter_idx;


static const ra8_port_pin_t k_er_pin_sck  = (ra8_port_pin_t)k_ra8_board_pmod2_spi_sck;

static const ra8_port_pin_t k_er_pin_cipo = (ra8_port_pin_t)k_ra8_board_pmod2_spi_cipo;

static const ra8_port_pin_t k_er_pin_copi = (ra8_port_pin_t)k_ra8_board_pmod2_spi_copi;

static const ra8_port_pin_t k_er_pin_cs   = (ra8_port_pin_t)k_ra8_board_pmod2_spi_cs;


/* ===========================================================================

 * Static storage

 * =========================================================================== */


RA8_BOARD_PANEL_FRAMEBUFFER(s_framebuffer);


static const display_cfg_t k_er_display_cfg = {

  .iface             = &k_display_backend_lcd_ra8_glcdc,

  .framebuffer       = s_framebuffer,

  .framebuffer_bytes = sizeof(s_framebuffer),

  .width_px          = (uint16_t)k_er_fb_w,

  .height_px         = (uint16_t)k_er_fb_h,

  .pixfmt            = k_display_pixfmt_rgb565,

  .panel_timing      = &s_ra8_panel_ek_ra8d2_timing,

};


static display_handle_t* s_display = nullptr;


display_fb_t s_fb;


ra8_ui_nav_t s_nav;


ra8_ui_target_t s_targets[k_er_max_targets];


uint16_t s_target_count;


ra8_kbd_layout_t s_kb;


ra8_kbd_text_t s_query;


uint32_t s_reading_page;


uint32_t s_reading_pages = 1U;


ra8_batt_monitor_t s_batt_mon;

ra8_batt_nag_t s_batt_nag = k_ra8_batt_nag_none;

uint8_t s_batt_soc = 0U;

bool s_nag_region_only = false;


static display_policy_t s_policy;


display_turn_event_t s_pending_event = k_display_event_chapter;


volatile uint32_t g_er_cur_page;

volatile uint32_t g_er_turns;

volatile uint32_t g_er_last_hint;

volatile uint32_t g_er_loop_ticks;


enum : uint16_t {

  k_er_clean_every = 8U,

};


er_loc_t s_loc_back[k_er_page_back_cap];


uint32_t s_loc_back_count;


[[gnu::section(".sdram_data")]] uint8_t s_font_buf[k_er_font_cap];


[[gnu::section(".sdram_data")]] uint8_t s_img_arena_buf[k_er_img_arena];


reflow_t s_reflow_engine;


bool s_reflow_open = false;

uint32_t s_reflow_chapter = (uint32_t)k_er_chapter_none;

int32_t s_reflow_w = 0;

int32_t s_reflow_h = 0;


uint32_t s_font_len;


bool s_have_font;


static uint32_t s_pclka_hz;


static const ra8_widget_vtable_t k_er_nag_vt = {.render = er_nag_render};


/* ===========================================================================

 * Boot helpers

 * =========================================================================== */


static void app_panic_halt(void)

{

  (void)ra8_board_led_on(k_ra8_board_led_red);

  while (1) {

    __asm__ volatile("wfi");

  }

}


static void app_bringup_clocks(void)

{

  uint32_t cpuclk0_hz = 0U;

  if (ra8_cgc_init() != k_ra8_ok) {

    app_panic_halt();

  }

  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {

    app_panic_halt();

  }

  if (ra8_mstp_init() != k_ra8_ok) {

    app_panic_halt();

  }

  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {

    app_panic_halt();

  }

  if (ra8_board_led_init(k_ra8_board_led_blue) != k_ra8_ok) {

    app_panic_halt();

  }

  if (ra8_board_led_init(k_ra8_board_led_red) != k_ra8_ok) {

    app_panic_halt();

  }

  ra8_isr_globals_enable();

}


static void app_bringup_panel(void)

{

  ra8_delay_ms((uint32_t)k_er_settle_ms);

  if (ra8_sdramc_init() != k_ra8_ok) {

    app_panic_halt();

  }

  if (display_init(&k_er_display_cfg, &s_display) != k_ra8_ok) {

    app_panic_halt();

  }

  if (display_get_framebuffer(s_display, &s_fb) != k_ra8_ok) {

    app_panic_halt();

  }

}


static void app_bringup_gfx(void)

{

  if (ra8_gfx_init(s_fb.pixels, s_fb.width_px, s_fb.height_px, k_ra8_gfx_format_rgb565) !=

      k_ra8_ok) {

    app_panic_halt();

  }

}


static void app_bringup_touch(void)

{

  const ra8_board_touch_cfg_t cfg = {

    .max_points = (uint8_t)k_er_touch_max_points,

    .irq_pin    = (uint8_t)k_ra8_touch_irq_pin_unset,

  };

  (void)ra8_board_touch_open(&cfg);

}


/* ===========================================================================

 * Optional SD-loaded font for the reflow Reading body

 * =========================================================================== */


static void er_try_load_font(void)

{

  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_pclka, &s_pclka_hz) != k_ra8_ok) {

    return;

  }

  const ra8_sdfont_cfg_t cfg = {

    .spi_channel    = (uint8_t)k_er_spi_chan,

    .sck            = k_er_pin_sck,

    .cipo           = k_er_pin_cipo,

    .copi           = k_er_pin_copi,

    .cs             = k_er_pin_cs,

    .pclka_hz       = s_pclka_hz,

    .filename       = "FONT.OTF",

    .provision_blob = nullptr, /* read-only: never write to the user's card */

    .provision_len  = 0U,

  };

  uint32_t got = 0U;

  if (ra8_sdfont_load(&cfg, s_font_buf, (uint32_t)k_er_font_cap, &got, nullptr) != k_ra8_ok) {

    return;

  }

  s_font_len  = got;

  s_have_font = true;

}


#ifdef RA8_APP_SETTINGS

static void er_render_settings(void)

{

  (void)ra8_gfx_clear((uint32_t)k_er_paper);

  (void)ra8_gfx_rect(0, 0, (int32_t)k_er_fb_w, (int32_t)k_er_statusbar_h, (uint32_t)k_er_ink, true);

  s_target_count = 0U;

}

#endif


/* ===========================================================================

 * App framework integration (#146)

 *

 * Each screen is re-expressed as an ``ra8_app``: the screen-id stack (``s_nav``)

 * remains the source of truth for *which* screen is active, and that id is the

 * active app's id, so ::er_render_current focuses the matching app and renders

 * its tree. The render callbacks are the existing ``er_render_*`` functions, so

 * the composited chrome is byte-identical (``just apps::emulator::golden`` stays green)

 * while the control flow is now an app composition rather than a hardcoded

 * if/else. ``RA8_APP_SETTINGS`` shows the build-time "uninstallable core" knob: a

 * Settings app is only registered when the macro is defined.

 * ===========================================================================

 */


static ra8_app_t s_app_library;

static ra8_app_t s_app_reader;

static ra8_app_t s_app_keyboard;

#ifdef RA8_APP_SETTINGS

static ra8_app_t s_app_settings;

#endif


static ra8_app_t*         s_app_slots[4];

static ra8_app_registry_t s_app_reg;


static void er_app_render(const ra8_app_t* a)

{

  if (a->id == (uint16_t)k_er_screen_reading) {

    er_render_reading();

  } else if (a->id == (uint16_t)k_er_screen_keyboard) {

    er_render_keyboard();

#ifdef RA8_APP_SETTINGS

  } else if (a->id == (uint16_t)k_er_screen_settings) {

    er_render_settings();

#endif

  } else {

    er_render_library();

  }

}


static const ra8_app_vtable_t k_er_app_vt = {

  .render = er_app_render,

};


static void er_apps_init(void)

{

  s_app_library  = (ra8_app_t){.vt        = &k_er_app_vt,

                               .id        = (uint16_t)k_er_screen_library,

                               .name      = "Library",

                               .removable = false};

  s_app_reader   = (ra8_app_t){.vt        = &k_er_app_vt,

                               .id        = (uint16_t)k_er_screen_reading,

                               .name      = "Reader",

                               .removable = false};

  s_app_keyboard = (ra8_app_t){.vt        = &k_er_app_vt,

                               .id        = (uint16_t)k_er_screen_keyboard,

                               .name      = "Search",

                               .removable = false};

  (void)ra8_app_registry_init(&s_app_reg,

                              s_app_slots,

                              (uint16_t)(sizeof(s_app_slots) / sizeof(s_app_slots[0])));

  (void)ra8_app_register(&s_app_reg, &s_app_library);

  (void)ra8_app_register(&s_app_reg, &s_app_reader);

  (void)ra8_app_register(&s_app_reg, &s_app_keyboard);

#ifdef RA8_APP_SETTINGS

  s_app_settings = (ra8_app_t){.vt        = &k_er_app_vt,

                               .id        = (uint16_t)k_er_screen_settings,

                               .name      = "Settings",

                               .removable = true};

  (void)ra8_app_register(&s_app_reg, &s_app_settings);

#endif

}


void er_render_current(void)

{

  uint16_t top = (uint16_t)k_er_screen_library;

  (void)ra8_ui_nav_top(&s_nav, &top);

  /* The nav top is the active screen-app's id: focus it (idempotent if already

   * focused, so no flicker) and render its widget tree. */

  (void)ra8_app_launch(&s_app_reg, top);

  (void)ra8_app_render(&s_app_reg);

  /* Low-battery nag (#145/#146): an app-framework-level overlay widget drawn

   * over whichever screen-app is active. A no-op at a healthy SOC, so the chrome

   * golden (rendered at the default battery) stays byte-identical. */

  if (s_batt_nag != k_ra8_batt_nag_none) {

    ra8_widget_t nag = {.vt = &k_er_nag_vt, .visible = true, .dirty = true};

    (void)ra8_widget_render_dirty(&nag, 1U);

  }

}


void er_render_nag_region(void)

{

  const int32_t nx = (int32_t)k_er_nag_margin;

  const int32_t ny = (int32_t)k_er_nag_top;

  const int32_t nw = (int32_t)s_fb.width_px - (2 * (int32_t)k_er_nag_margin);

  const int32_t nh = (int32_t)k_er_nag_h;

  if (ra8_gfx_set_clip(nx, ny, nw, nh) != k_ra8_ok) {

    er_render_current(); /* clip unavailable -> safe full repaint. */

    return;

  }

  uint16_t top = (uint16_t)k_er_screen_library;

  (void)ra8_ui_nav_top(&s_nav, &top);

  (void)ra8_app_launch(&s_app_reg, top);

  (void)ra8_app_render(&s_app_reg);

  if (s_batt_nag != k_ra8_batt_nag_none) {

    ra8_widget_t nag = {.vt = &k_er_nag_vt, .visible = true, .dirty = true};

    (void)ra8_widget_render_dirty(&nag, 1U);

  }

  (void)ra8_gfx_reset_clip();

}


void er_flush_event(display_turn_event_t event)

{

  display_policy_decision_t dec = {};

  if (display_policy_decide(&s_policy, event, &dec) != k_ra8_ok) {

    dec.hint = k_display_refresh_quality; /* safe fallback: a clean full update */

  }

  display_rect_t rect = {};

  if (display_policy_full_rect(s_fb.width_px, s_fb.height_px, &rect) != k_ra8_ok) {

    rect = display_full_rect(s_display);

  }

  (void)display_flush(s_display, rect, dec.hint);

  g_er_last_hint = (uint32_t)dec.hint;

  g_er_cur_page  = s_reading_page;

}


void main(void)

{

  app_bringup_clocks();

  app_bringup_panel();

  app_bringup_gfx();

  app_bringup_touch();

  (void)ra8_batt_monitor_init(&s_batt_mon); /* low-battery nag policy (#145/#146) */

  /* User switches SW1/SW2 as inputs with internal pull-ups (active-low). Best-

   * effort: a config failure just leaves page-turn on the touch path. */

  (void)ra8_board_sw_init(k_ra8_board_sw1);

  (void)ra8_board_sw_init(k_ra8_board_sw2);

  er_try_load_font(); /* Best-effort SD font for the reflow Reading body. */


  /* Default refresh cadence: fast A2 turns with a periodic GC16 clean (#78). */

  (void)display_policy_init(&s_policy, k_display_policy_fast_clean, (uint16_t)k_er_clean_every);

  (void)ra8_ui_nav_init(&s_nav, (uint16_t)k_er_screen_library);

  er_apps_init(); /* re-express the screens as ra8_app instances (#146) */

  er_render_current();

  er_flush_event(k_display_event_open); /* boot -> a clean INIT panel update */


  while (1) {

    er_poll_touch();   /* fast cadence so taps feel responsive   */

    er_poll_buttons(); /* page-turn switches                     */

    er_poll_battery(); /* self-throttled (~1 Hz) low-battery nag */

    /* Heartbeat LED toggles on a slow sub-cadence so it blinks (~1 Hz) instead

     * of strobing at the input-poll rate. */

    if ((g_er_loop_ticks % (uint32_t)k_er_led_every) == 0U) {

      (void)ra8_board_led_toggle(k_ra8_board_led_blue);

    }

    /* Free-running liveness counter: the jlink_memprobe HIL reads it twice across

     * a window and asserts the render/poll loop advanced (it never WFIs). */

    g_er_loop_ticks++;

    ra8_delay_ms((uint32_t)k_er_frame_ms);

  }

}


main
void main(void)
Secure fallback main entry point.
Definition main.c:37

s_pclka_hz
static uint32_t s_pclka_hz
Definition c6_cam_app.c:38

er_pageturn.h
Pure page-turn + input-region decisions for the e-reader (#78).

ereader_ui_steps.h
E-reader UI chrome – shared contract between main.c and the per-aspect helper translation units (scre...

k_er_spine_count
@ k_er_spine_count
Number of chapters in k_er_spine.
Definition ereader_ui_steps.h:339

s_have_font
bool s_have_font
True once an SD font is loaded.
Definition main.c:291

k_er_count_text
const char k_er_count_text[]
Book-count chip text.
Definition main.c:85

k_er_paper
@ k_er_paper
Page background (g15).
Definition ereader_ui_steps.h:77

k_er_ink
@ k_er_ink
Primary text / glyphs (g0).
Definition ereader_ui_steps.h:78

k_er_fb_w
@ k_er_fb_w
Framebuffer width (pixels).
Definition ereader_ui_steps.h:58

k_er_fb_h
@ k_er_fb_h
Framebuffer height (pixels).
Definition ereader_ui_steps.h:59

er_poll_buttons
void er_poll_buttons(void)
Poll SW1/SW2 and turn a page on a fresh press (#78).
Definition ereader_ui_input.c:589

s_reflow_open
bool s_reflow_open
True while the engine holds a layout.
Definition main.c:280

k_er_search_hint
const char k_er_search_hint[]
Search placeholder.
Definition main.c:84

s_targets
ra8_ui_target_t s_targets[]
Tap targets for the current screen.
Definition main.c:217

s_reflow_engine
reflow_t s_reflow_engine
reflow engine for the body.
Definition main.c:277

s_kb
ra8_kbd_layout_t s_kb
On-screen keyboard grid.
Definition main.c:223

s_query
ra8_kbd_text_t s_query
Live search query.
Definition main.c:226

k_er_img_arena
@ k_er_img_arena
SDRAM image-decode scratch.
Definition ereader_ui_steps.h:269

k_er_font_cap
@ k_er_font_cap
Max font read off the card (bytes).
Definition ereader_ui_steps.h:263

k_er_spi_chan
@ k_er_spi_chan
Pmod2 / J25 = SCI0 Simple-SPI.
Definition ereader_ui_steps.h:266

k_er_body_lines
const char *const k_er_body_lines[]
Reading-view body paragraph lines (pre-wrapped for the font).
Definition main.c:110

s_chapter_idx
uint32_t s_chapter_idx
Reading chapter index.
Definition main.c:178

s_target_count
uint16_t s_target_count
Tap targets currently populated.
Definition main.c:220

s_reflow_chapter
uint32_t s_reflow_chapter
Chapter laid out (cache key).
Definition main.c:282

s_nag_region_only
bool s_nag_region_only
True when a tap only toggled the nag.
Definition main.c:241

g_er_turns
volatile uint32_t g_er_turns
Count of page turns applied since boot.
Definition main.c:255

k_er_nav_items
const char *const k_er_nav_items[]
Bottom-nav destinations (Library / Store / Notes / Settings).
Definition main.c:91

k_er_page_back_cap
@ k_er_page_back_cap
Footnote-jump back-stack depth.
Definition ereader_ui_steps.h:225

k_er_max_targets
@ k_er_max_targets
Max collected tap targets.
Definition ereader_ui_steps.h:223

k_er_page_label
const char k_er_page_label[]
Reading page label.
Definition main.c:87

k_er_statusbar_h
@ k_er_statusbar_h
Top status-bar band height.
Definition ereader_ui_steps.h:91

k_er_touch_max_points
@ k_er_touch_max_points
One contact = one tap.
Definition ereader_ui_steps.h:176

s_pending_event
display_turn_event_t s_pending_event
Pending refresh event for next flush.
Definition main.c:251

er_render_reading
void er_render_reading(void)
Render the full Reading screen (status bar, body, footer).
Definition ereader_ui_screens.c:848

s_reflow_w
int32_t s_reflow_w
Body width the layout used.
Definition main.c:284

k_er_book_title
const char k_er_book_title[]
Reading title text.
Definition main.c:86

s_img_arena_buf
uint8_t s_img_arena_buf[]
Image-decode bump arena in SDRAM.
Definition main.c:274

k_er_nav_count
@ k_er_nav_count
Number of bottom-nav destinations.
Definition ereader_ui_steps.h:308

er_nag_render
void er_nag_render(ra8_widget_t *w)
Nag banner overlay widget: a centered low-battery toast over the screen.
Definition ereader_ui_input.c:375

s_batt_mon
ra8_batt_monitor_t s_batt_mon
Low-battery nag policy state.
Definition main.c:235

g_er_last_hint
volatile uint32_t g_er_last_hint
Last display_refresh_hint_t flushed.
Definition main.c:256

k_er_nag_margin
@ k_er_nag_margin
Banner inset from the screen sides.
Definition ereader_ui_steps.h:201

k_er_nag_h
@ k_er_nag_h
Banner height (px).
Definition ereader_ui_steps.h:200

k_er_nag_top
@ k_er_nag_top
Banner top y (clear of the status bar).
Definition ereader_ui_steps.h:202

k_er_status_right
const char k_er_status_right[]
Status-bar right text.
Definition main.c:83

s_reflow_h
int32_t s_reflow_h
Body height the layout used.
Definition main.c:285

s_loc_back_count
uint32_t s_loc_back_count
Entries used in s_loc_back.
Definition main.c:268

s_loc_back
er_loc_t s_loc_back[]
Reading back-stack for link jumps.
Definition main.c:265

s_reading_pages
uint32_t s_reading_pages
Reading total reflow pages (>= 1).
Definition main.c:232

k_er_chapter
const char k_er_chapter[]
Bitmap-fallback heading.
Definition main.c:88

s_batt_nag
ra8_batt_nag_t s_batt_nag
Nag currently shown over the chrome.
Definition main.c:237

k_er_wordmark
const char k_er_wordmark[6]
Wordmark / status text.
Definition main.c:80

s_reading_page
uint32_t s_reading_page
Reading current reflow page.
Definition main.c:229

k_er_spine
const er_chapter_t k_er_spine[]
Two-chapter mock spine for in-content cross-chapter navigation (#110).
Definition main.c:164

k_er_books
const er_book_t k_er_books[]
Demo shelf (public-domain works).
Definition main.c:96

er_poll_battery
void er_poll_battery(void)
Poll the fuel gauge, fold it into the nag policy, and toggle the banner.
Definition ereader_ui_input.c:626

k_er_lib_heading
const char k_er_lib_heading[]
Library heading text.
Definition main.c:82

k_er_book_count
@ k_er_book_count
Number of demo books.
Definition ereader_ui_steps.h:319

k_er_chapter_none
@ k_er_chapter_none
s_reflow_chapter when nothing is laid out.
Definition ereader_ui_steps.h:281

k_er_body_line_count
@ k_er_body_line_count
Number of pre-wrapped body lines.
Definition ereader_ui_steps.h:329

er_render_keyboard
void er_render_keyboard(void)
Render the on-screen keyboard screen + collect its key targets.
Definition ereader_ui_input.c:267

k_er_screen_reading
@ k_er_screen_reading
Reading view.
Definition ereader_ui_steps.h:140

k_er_screen_keyboard
@ k_er_screen_keyboard
On-screen keyboard (search entry).
Definition ereader_ui_steps.h:141

k_er_screen_library
@ k_er_screen_library
Library / home grid.
Definition ereader_ui_steps.h:139

k_er_screen_settings
@ k_er_screen_settings
Settings (optional app, if RA8_APP_SETTINGS).
Definition ereader_ui_steps.h:142

s_batt_soc
uint8_t s_batt_soc
Last fuel-gauge SOC percent.
Definition main.c:239

s_font_len
uint32_t s_font_len
Bytes of font read off the card.
Definition main.c:288

er_poll_touch
void er_poll_touch(void)
Poll the touch controller and dispatch a tap on a fresh press.
Definition ereader_ui_input.c:558

k_er_settle_ms
@ k_er_settle_ms
PLL / SDRAM / panel-POR settle.
Definition ereader_ui_steps.h:67

k_er_frame_ms
@ k_er_frame_ms
Input poll period (ms): touch / button cadence.
Definition ereader_ui_steps.h:68

k_er_led_every
@ k_er_led_every
Toggle the heartbeat LED every Nth frame.
Definition ereader_ui_steps.h:69

g_er_cur_page
volatile uint32_t g_er_cur_page
SWD / --dump-sym telemetry for the headless page-turn HIL (#78).
Definition main.c:254

er_render_library
void er_render_library(void)
Render the full Library screen.
Definition ereader_ui_screens.c:545

s_display
static display_handle_t * s_display
Definition main.c:78

s_framebuffer
static uint16_t s_framebuffer[(size_t) k_panel_height_px *(size_t) k_panel_width_px]
1024x600 RGB565 framebuffer in external SDRAM (GLCDC scans this).
Definition main.c:67

s_font_buf
static uint8_t s_font_buf[k_pc_font_cap]
Font blob read off the card.
Definition main.c:197

s_fb
static display_fb_t s_fb
Definition main.c:203

app_bringup_touch
static void app_bringup_touch(void)
Open the GT911 touch controller (best-effort, polled; non-fatal).
Definition main.c:461

app_bringup_clocks
static void app_bringup_clocks(void)
Bring up clocks, MSTP, SysTick, the SCI8 console and both LEDs.
Definition main.c:414

app_bringup_panel
static void app_bringup_panel(void)
Bring up external SDRAM + the GLCDC panel, then cache the FB.
Definition main.c:437

app_panic_halt
static void app_panic_halt(void)
Halt forever with the red board LED on (visual sign of fatal init).
Definition main.c:405

app_bringup_gfx
static void app_bringup_gfx(void)
Bind ra8_gfx to the panel framebuffer.
Definition main.c:452

s_nav
static ra8_app_nav_t s_nav
Navigation back-stack layered over s_reg.
Definition main.c:236

s_policy
static display_policy_t s_policy
Refresh-cadence policy driving e-ink page-turn waveforms (#78).
Definition main.c:244

s_app_library
static ra8_app_t s_app_library
Library / Reading / Keyboard (+ optional Settings) app instances.
Definition main.c:523

er_try_load_font
static void er_try_load_font(void)
Best-effort: load FONT.OTF off the Pmod2 SD card into s_font_buf.
Definition main.c:462

g_er_loop_ticks
volatile uint32_t g_er_loop_ticks
Free-running main-loop counter – HIL liveness.
Definition main.c:257

k_er_app_vt
static const ra8_app_vtable_t k_er_app_vt
Vtable shared by every screen-app (render-only; nav owns transitions).
Definition main.c:551

k_er_nag_vt
static const ra8_widget_vtable_t k_er_nag_vt
Nag banner overlay widget vtable (renderer lives in the input TU).
Definition main.c:297

er_app_render
static void er_app_render(const ra8_app_t *a)
App render trampoline: dispatch to the screen render by app id.
Definition main.c:535

er_apps_init
static void er_apps_init(void)
Register the e-reader screen-apps into s_app_reg.
Definition main.c:556

s_app_reader
static ra8_app_t s_app_reader
Definition main.c:524

k_er_pin_sck
static const ra8_port_pin_t k_er_pin_sck
Pmod2 SPI pins (J25) – SCI0 Simple-SPI, per sd_font_render.
Definition main.c:181

s_app_slots
static ra8_app_t * s_app_slots[4]
App registry storage (4 slots: 3 core + an optional Settings).
Definition main.c:531

er_flush_event
void er_flush_event(display_turn_event_t event)
Flush the panel for a refresh event through the cadence policy (#78).
Definition main.c:623

k_er_pin_copi
static const ra8_port_pin_t k_er_pin_copi
Definition main.c:183

k_er_clean_every
@ k_er_clean_every
Er clean every.
Definition main.c:261

k_er_chapter2_xhtml
static const char k_er_chapter2_xhtml[]
Reading-view chapter two (cross-chapter <a href> link target).
Definition main.c:156

k_er_chapter_xhtml
static const char k_er_chapter_xhtml[]
Reading-view chapter as XHTML, reflowed by reflow when an SD font is present (the same prose as k_er_...
Definition main.c:133

k_er_pin_cs
static const ra8_port_pin_t k_er_pin_cs
Definition main.c:184

er_render_current
void er_render_current(void)
Render whichever screen is on top of the navigation stack.
Definition main.c:585

k_er_pin_cipo
static const ra8_port_pin_t k_er_pin_cipo
Definition main.c:182

s_app_keyboard
static ra8_app_t s_app_keyboard
Definition main.c:525

er_render_nag_region
void er_render_nag_region(void)
Repaint only the low-battery banner rect (dirty-region update).
Definition main.c:602

k_er_display_cfg
static const display_cfg_t k_er_display_cfg
Display PAL config – LCD/GLCDC backend over the SDRAM buffer.
Definition main.c:197

s_app_reg
static ra8_app_registry_t s_app_reg
Definition main.c:532

literata_latin1.h
Declaration of the Latin-1 Literata font baked into internal flash.

ra8_app.h
Zero-heap app framework: lifecycle + static registry + launcher (#146).

ra8_app_launch
ra8_err_t ra8_app_launch(ra8_app_registry_t *reg, uint16_t id)
Launch (focus) the app with id, running the focus lifecycle.
Definition ra8_app.c:78

ra8_app_register
ra8_err_t ra8_app_register(ra8_app_registry_t *reg, ra8_app_t *app)
Register an app (calls its init once) and add it to the registry.
Definition ra8_app.c:48

ra8_app_render
ra8_err_t ra8_app_render(ra8_app_registry_t *reg)
Run the focused app's render (on-target; no-op if none / NULL).
Definition ra8_app.c:153

ra8_app_registry_init
ra8_err_t ra8_app_registry_init(ra8_app_registry_t *reg, ra8_app_t **storage, uint16_t cap)
Bind a registry to caller-owned pointer storage (empty, no focus).
Definition ra8_app.c:20

ra8_batt.h
Bounded, allocation-free low-battery nag policy.

ra8_batt_nag_t
ra8_batt_nag_t
The low-battery warning a single ra8_batt_update step raises.
Definition ra8_batt.h:54

k_ra8_batt_nag_none
@ k_ra8_batt_nag_none
No new warning this step.
Definition ra8_batt.h:55

ra8_batt_monitor_init
ra8_err_t ra8_batt_monitor_init(ra8_batt_monitor_t *mon)
Reset a nag monitor to the un-nagged, fully-armed state.
Definition ra8_batt.c:27

ra8_board_ek_ra8d2.h
Board-support layer for the Renesas EK-RA8D2 v1 evaluation kit.

ra8_board_led_toggle
ra8_err_t ra8_board_led_toggle(ra8_board_led_id_t led)
Toggle led's output state.
Definition ra8_board_ek_ra8d2.c:121

ra8_board_sw_init
ra8_err_t ra8_board_sw_init(ra8_board_sw_id_t sw)
Configure a switch pin as an input with internal pull-up.
Definition ra8_board_ek_ra8d2.c:165

k_ra8_board_pmod2_spi_cipo
@ k_ra8_board_pmod2_spi_cipo
Pmod2.3 CIPO (CIPO0_B), P602.
Definition ra8_board_ek_ra8d2_connectors.h:681

k_ra8_board_pmod2_spi_cs
@ k_ra8_board_pmod2_spi_cs
Pmod2.1 CS (SS0_B), P604.
Definition ra8_board_ek_ra8d2_connectors.h:676

k_ra8_board_pmod2_spi_copi
@ k_ra8_board_pmod2_spi_copi
Pmod2.2 COPI (COPI0_B), P603.
Definition ra8_board_ek_ra8d2_connectors.h:678

k_ra8_board_pmod2_spi_sck
@ k_ra8_board_pmod2_spi_sck
Pmod2.4 SCK (SCK0_B), P601.
Definition ra8_board_ek_ra8d2_connectors.h:684

k_ra8_board_sw1
@ k_ra8_board_sw1
SW1, P009, IRQ13-DS (jumper E31).
Definition ra8_board_ek_ra8d2_connectors.h:176

k_ra8_board_sw2
@ k_ra8_board_sw2
SW2, P008, IRQ12-DS (jumper E32).
Definition ra8_board_ek_ra8d2_connectors.h:177

ra8_board_led_init
ra8_err_t ra8_board_led_init(ra8_board_led_id_t led)
Configure led as a digital output, initial level low (off).
Definition ra8_board_ek_ra8d2.c:91

ra8_board_led_on
ra8_err_t ra8_board_led_on(ra8_board_led_id_t led)
Drive led HIGH (light it).
Definition ra8_board_ek_ra8d2.c:101

k_ra8_board_led_blue
@ k_ra8_board_led_blue
Convenience aliases by colour.
Definition ra8_board_ek_ra8d2_connectors.h:106

k_ra8_board_led_red
@ k_ra8_board_led_red
RA8 board led red.
Definition ra8_board_ek_ra8d2_connectors.h:108

ra8_board_ek_ra8d2_touch.h
One-call bring-up of the EK-RA8D2 panel's GoodIX GT911 touch controller.

ra8_board_touch_open
ra8_err_t ra8_board_touch_open(const ra8_board_touch_cfg_t *cfg)
Bring the on-board GT911 up and open the touch driver against it.
Definition ra8_board_ek_ra8d2_touch.c:60

ra8_boot_entry.h
Boot entry points shared between a vector table and its startup code.

ra8_box.h
Bounded, allocation-free box-model layout for e-reader chrome.

ra8_cgc.h
High-level Clock Generation Circuit driver.

ra8_cgc_get_clock_hz
ra8_err_t ra8_cgc_get_clock_hz(ra8_clock_id_t id, uint32_t *out_hz)
Query the current frequency of a clock-tree domain.
Definition ra8_cgc.c:132

k_ra8_clock_id_cpuclk0
@ k_ra8_clock_id_cpuclk0
Cortex-M85 CPUCLK0.
Definition ra8_cgc.h:70

k_ra8_clock_id_pclka
@ k_ra8_clock_id_pclka
PCLKA.
Definition ra8_cgc.h:73

ra8_cgc_init
ra8_err_t ra8_cgc_init(void)
Configure the clock tree to a safe default.
Definition ra8_cgc.c:727

ra8_display_pal.h
Display Platform Abstraction Layer for the RA8D2.

k_display_pixfmt_rgb565
@ k_display_pixfmt_rgb565
16 bpp, 5/6/5 packed.
Definition ra8_display_pal.h:99

display_full_rect
display_rect_t display_full_rect(const display_handle_t *d)
Convenience helper returning the rect covering the whole framebuffer.
Definition ra8_display_pal.c:173

display_get_framebuffer
ra8_err_t display_get_framebuffer(const display_handle_t *d, display_fb_t *out)
Return the framebuffer descriptor the backend is targeting.
Definition ra8_display_pal.c:129

display_flush
ra8_err_t display_flush(const display_handle_t *d, display_rect_t rect, display_refresh_hint_t hint)
Commit pending framebuffer changes to the panel.
Definition ra8_display_pal.c:139

display_handle_t
struct display_handle display_handle_t
Definition ra8_display_pal.h:222

display_init
ra8_err_t display_init(const display_cfg_t *cfg, display_handle_t **out_handle)
Initialise the display PAL and bring the selected backend up to a state where display_flush succeeds.
Definition ra8_display_pal.c:93

k_display_refresh_quality
@ k_display_refresh_quality
Prioritise final quality.
Definition ra8_display_pal.h:123

ra8_display_pal_lcd.h
LCD backend (ra8_glcdc) for the display PAL.

k_display_backend_lcd_ra8_glcdc
const display_backend_iface_t k_display_backend_lcd_ra8_glcdc
LCD backend vtable – pass its address through display_cfg_t.iface to drive the EK-RA8D2 panel.
Definition ra8_display_pal_lcd.c:566

ra8_display_pal_policy.h
Pluggable page-turn refresh-cadence policy for bistable (e-ink) panels.

display_policy_init
ra8_err_t display_policy_init(display_policy_t *p, display_policy_kind_t kind, uint16_t clean_every)
Initialise a refresh-cadence policy.
Definition ra8_display_pal_policy.c:118

k_display_policy_fast_clean
@ k_display_policy_fast_clean
A2 partial, periodic GC16 clean (default).
Definition ra8_display_pal_policy.h:51

display_turn_event_t
display_turn_event_t
The page-transition event the policy reacts to.
Definition ra8_display_pal_policy.h:60

k_display_event_chapter
@ k_display_event_chapter
Chapter-boundary turn – wants a clean refresh.
Definition ra8_display_pal_policy.h:63

k_display_event_open
@ k_display_event_open
Book/first page opened – wants a clean INIT.
Definition ra8_display_pal_policy.h:61

display_policy_full_rect
ra8_err_t display_policy_full_rect(uint16_t w, uint16_t h, display_rect_t *out)
Build the full-page damage rectangle for a page turn.
Definition ra8_display_pal_policy.c:167

display_policy_decide
ra8_err_t display_policy_decide(display_policy_t *p, display_turn_event_t event, display_policy_decision_t *out)
Decide the flush parameters for one page-transition event.
Definition ra8_display_pal_policy.c:131

ra8_err.h
Error Code Definitions for ra8-firmware.

k_ra8_ok
@ k_ra8_ok
Success – operation completed with all postconditions satisfied.
Definition ra8_err.h:119

ra8_gfx.h
Software 2D graphics primitives layered on top of a caller-ownedframebuffer (DRW / D/AVE 2D / GLCDC r...

k_ra8_gfx_format_rgb565
@ k_ra8_gfx_format_rgb565
16-bit RGB565, little-endian in memory.
Definition ra8_gfx.h:40

ra8_gfx_reset_clip
ra8_err_t ra8_gfx_reset_clip(void)
Reset the clip rectangle to the whole framebuffer.
Definition ra8_gfx_text.c:616

ra8_gfx_set_clip
ra8_err_t ra8_gfx_set_clip(int32_t x, int32_t y, int32_t w, int32_t h)
Restrict all subsequent drawing to a rectangle (dirty-region updates).
Definition ra8_gfx_text.c:580

ra8_gfx_clear
ra8_err_t ra8_gfx_clear(uint32_t color)
Fill the bound framebuffer's clip region with a single colour.
Definition ra8_gfx_text.c:549

ra8_gfx_init
ra8_err_t ra8_gfx_init(void *fb, uint16_t width, uint16_t height, ra8_gfx_format_t format)
Bind ra8_gfx to a caller-owned framebuffer.
Definition ra8_gfx_text.c:522

ra8_gfx_rect
ra8_err_t ra8_gfx_rect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color, bool filled)
Draw an axis-aligned rectangle.
Definition ra8_gfx_text.c:818

ra8_isr.h
NVIC + ICU IELSR allocator.

ra8_isr_globals_enable
void ra8_isr_globals_enable(void)
Globally enable maskable interrupts (PRIMASK = 0).
Definition ra8_isr.c:439

ra8_mstp.h
Ref-counted Module Stop Control wrapper for the RA8D2.

ra8_mstp_init
ra8_err_t ra8_mstp_init(void)
Re-establish the ra8_mstp ref-count table from current hardware state.
Definition ra8_mstp.c:291

RA8_BOARD_PANEL_FRAMEBUFFER
#define RA8_BOARD_PANEL_FRAMEBUFFER(name)
Declare a correctly aligned, sized and placed RGB565 framebuffer for the on-board panel.
Definition ra8_panel.h:165

ra8_panel_timing.h
EK-RA8D2 panel timing as the HAL's ra8_glcdc_timing_t (ER-TFT070-6).

s_ra8_panel_ek_ra8d2_timing
static const ra8_glcdc_timing_t s_ra8_panel_ek_ra8d2_timing
EK-RA8D2 ER-TFT070-6 RGB timing for ra8_glcdc_init / the LCD backend.
Definition ra8_panel_timing.h:29

ra8_port_constants.h
Typed Port / Pin Constants for the RA8D2 IOPORT Module.

ra8_port_pin_t
ra8_port_pin_t
Packed (port << 8) | pin pin identifier.
Definition ra8_port_constants.h:147

ra8_port_utils.h
High-level GPIO helpers on top of the PORT + PFS register layer.

ra8_sdfont.h
Load a TTF/OTF font off a Pmod SD card, self-provisioning if absent.

ra8_sdfont_load
ra8_err_t ra8_sdfont_load(const ra8_sdfont_cfg_t *cfg, uint8_t *buf, uint32_t cap, uint32_t *out_len, ra8_sdfont_source_t *out_source)
Mount the Pmod SD card and load a font, provisioning it if absent.
Definition ra8_sdfont.c:392

ra8_sdramc.h
External SDRAM controller driver (framework).

ra8_sdramc_init
ra8_err_t ra8_sdramc_init(void)
Initialise the external SDRAM at k_ra8_sdram_base_addr.
Definition ra8_sdramc.c:257

ra8_time.h
SysTick-based tick counter, delay and timestamp helpers.

ra8_time_init
ra8_err_t ra8_time_init(uint32_t cpu_hz)
Initialise SysTick for a 1 kHz tick interrupt.
Definition ra8_time.c:59

ra8_delay_ms
void ra8_delay_ms(uint32_t ms)
Busy-wait for at least ms milliseconds.
Definition ra8_time.c:129

ra8_touch.h
Multi-touch input driver – GoodIX GT911 backend.

k_ra8_touch_irq_pin_unset
@ k_ra8_touch_irq_pin_unset
Sentinel for "no IRQ pin attached".
Definition ra8_touch.h:72

ra8_ui.h
Bounded UI interaction core: hit-testing, screen stack, paging.

ra8_ui_nav_init
ra8_err_t ra8_ui_nav_init(ra8_ui_nav_t *nav, uint16_t root_screen)
Initialise a navigation stack with a root screen.
Definition ra8_ui.c:71

ra8_ui_nav_top
ra8_err_t ra8_ui_nav_top(const ra8_ui_nav_t *nav, uint16_t *out_screen)
Read the current (top) screen id.
Definition ra8_ui.c:115

ra8_widget_render_dirty
ra8_err_t ra8_widget_render_dirty(ra8_widget_t *widgets, uint16_t count)
Render every visible + dirty widget, clearing its damage.
Definition ra8_widget.c:331

reflow.h
HTML / CSS reflow + paginate engine for the ra8d2 ereader.

display_cfg_t
Configuration descriptor passed into display_init.
Definition ra8_display_pal.h:240

display_fb_t
Framebuffer descriptor returned by display_get_framebuffer.
Definition ra8_display_pal.h:167

display_policy_decision_t
What the app should pass to display_flush for this event.
Definition ra8_display_pal_policy.h:100

display_policy_decision_t::hint
display_refresh_hint_t hint
Waveform intent (fast/quality/init).
Definition ra8_display_pal_policy.h:101

display_policy_t
Caller-owned policy state (zero heap; init once, decide per turn).
Definition ra8_display_pal_policy.h:88

display_rect_t
Rectangle in framebuffer coordinates passed into display_flush.
Definition ra8_display_pal.h:188

er_book_t
One library entry: title, author, reading progress percent.
Definition ereader_ui_steps.h:232

er_chapter_t
One mock-spine chapter: its XHTML, length, and resolving href.
Definition ereader_ui_steps.h:242

er_loc_t
A reading location (chapter + page) for the navigation back-stack.
Definition ereader_ui_steps.h:253

ra8_app_registry_t
Fixed table of registered apps + the focused index.
Definition ra8_app.h:161

ra8_app_t
One app instance + its metadata (caller-owned, static).

ra8_app_vtable_t
App lifecycle callbacks (shared by all instances of one app).
Definition ra8_app.h:133

ra8_batt_monitor_t
Caller-owned nag state carried across ra8_batt_update calls.
Definition ra8_batt.h:85

ra8_board_touch_cfg_t
The two touch settings that are an APPLICATION choice, not a board fact.
Definition ra8_board_ek_ra8d2_touch.h:83

ra8_kbd_layout_t
The key grid for the active layer, plus SHIFT / layer / frame state.
Definition ra8_keyboard.h:96

ra8_kbd_text_t
The typed query buffer + commit state.
Definition ra8_keyboard.h:110

ra8_sdfont_cfg_t
SD-card font-store bus description + provisioning policy.
Definition ra8_sdfont.h:92

ra8_ui_nav_t
Fixed-depth screen-id stack (caller-owned).
Definition ra8_ui.h:163

ra8_ui_target_t
One tap target: a rectangle bound to an opaque action id.
Definition ra8_ui.h:83

ra8_widget_t
One widget instance (caller-owned, no allocation).

ra8_widget_vtable_t
Behaviour table shared by all widgets of one kind.
Definition ra8_widget.h:121

reflow_t
Reflow / pagination engine state.
Definition reflow_types.h:448