board_overlay.c

Go to the documentation of this file.

 
#include "board_overlay.h"
 
#include <stdint.h>
#include <stdio.h>
 
#include "board_overlay_internal.h"

typedef struct {
  uint16_t* pixels; 
  uint16_t  stride; 
} overlay_memory_context_t;

RA8_INTERNAL static bool internal_memory_fill(void*    context,
                                              uint16_t x,
                                              uint16_t y,
                                              uint16_t width,
                                              uint16_t height,
                                              uint16_t color)
{
  overlay_memory_context_t* const memory = (overlay_memory_context_t*)context;
  if ((memory == nullptr) || (memory->pixels == nullptr)) {
    return false;
  }
  for (uint16_t row = 0U; row < height; row++) {
    uint16_t* const begin =
      &memory->pixels[((size_t)(y + row) * (size_t)memory->stride) + (size_t)x];
    for (uint16_t column = 0U; column < width; column++) {
      begin[column] = color;
    }
  }
  return true;
}

RA8_INTERNAL static void internal_draw_led(board_overlay_surface_t*  surface,
                                           int32_t                   x,
                                           int32_t                   y,
                                           const board_led_status_t* led)
{
  enum : int32_t {
    k_dot = 18, 
  };
  priv_fill_rect(surface, x - 1, y - 1, k_dot + 2, k_dot + 2, (uint16_t)k_ovl_led_ring);
  const uint16_t fill = led->on ? led->color : (uint16_t)k_ovl_led_off;
  priv_fill_rect(surface, x, y, k_dot, k_dot, fill);
  priv_draw_text(surface,
                 x + k_dot + 8,
                 y + k_led_label_dy,
                 (led->label != nullptr) ? led->label : "LED",
                 (uint16_t)k_ovl_text,
                 1);
}

RA8_INTERNAL static int32_t
internal_draw_leds(board_overlay_surface_t* surface, int32_t x, int32_t y, const board_status_t* st)
{
  const int32_t row_y = priv_section_head(surface, x, y, "LEDS");
  for (uint32_t i = 0U; i < (uint32_t)k_overlay_led_count; i++) {
    internal_draw_led(surface, x + ((int32_t)i * k_led_col_dx), row_y, &st->leds[i]);
  }
  return row_y + k_led_row_h;
}

RA8_INTERNAL static int32_t internal_draw_run_stats(board_overlay_surface_t* surface,
                                                    int32_t                  x,
                                                    int32_t                  y,
                                                    const board_status_t*    st)
{
  enum : uint8_t {
    k_run_row_cap = 64U, 
  };
  char    buf[k_run_row_cap];
  int32_t cy = priv_section_head(surface, x, y, "RUN");
  (void)snprintf(buf, sizeof(buf), "0x%08X", st->pc);
  cy = priv_kv_row(surface, x, cy, "pc", buf, (uint16_t)k_ovl_heading);
  (void)snprintf(buf, sizeof(buf), "%s   chunk %u", st->running ? "RUNNING" : "parked", st->chunks);
  cy = priv_kv_row(surface,
                   x,
                   cy,
                   "state",
                   buf,
                   st->running ? (uint16_t)k_ovl_ok : (uint16_t)k_ovl_dim);
  (void)snprintf(buf, sizeof(buf), "%u rd / %u wr", st->mmio_reads, st->mmio_writes);
  cy = priv_kv_row(surface, x, cy, "mmio", buf, (uint16_t)k_ovl_text);
  return cy;
}

RA8_INTERNAL static int32_t internal_draw_io_block(board_overlay_surface_t* surface,
                                                   int32_t                  x,
                                                   int32_t                  y,
                                                   const board_status_t*    st)
{
  enum : uint8_t {
    k_io_row_cap = 96U, 
  };
  char    buf[k_io_row_cap];
  int32_t cy = priv_section_head(surface, x, y, "I/O");
  cy         = priv_kv_row(surface,
                           x,
                           cy,
                           "usb",
                           (st->usb_state != nullptr) ? st->usb_state : "-",
                           (uint16_t)k_ovl_text);
  (void)
    snprintf(buf, sizeof(buf), "%u total  IRQ0 x%u  IRQ1 x%u", st->irq_total, st->irq0, st->irq1);
  cy = priv_kv_row(surface, x, cy, "irq", buf, (uint16_t)k_ovl_text);
  if (st->has_touch) {
    (void)snprintf(buf, sizeof(buf), "%u, %u", st->touch_x, st->touch_y);
  } else {
    (void)snprintf(buf, sizeof(buf), "-");
  }
  cy                        = priv_kv_row(surface, x, cy, "touch", buf, (uint16_t)k_ovl_text);
  const bool          sd_gb = (st->sd_bytes >= (k_sd_unit_div * k_sd_unit_div * k_sd_unit_div));
  const unsigned long sd_sz =
    sd_gb ? (unsigned long)(st->sd_bytes / (k_sd_unit_div * k_sd_unit_div * k_sd_unit_div))
          : (unsigned long)(st->sd_bytes / (k_sd_unit_div * k_sd_unit_div));
  const char* sd_u = sd_gb ? "GB" : "MB";
  if (!st->sd_attached) {
    (void)snprintf(buf, sizeof(buf), "-");
  } else if (st->sd_fat_bits != 0U) {
    (void)snprintf(buf,
                   sizeof(buf),
                   "%lu %s FAT%u %s",
                   sd_sz,
                   sd_u,
                   (unsigned)st->sd_fat_bits,
                   (st->sd_label != nullptr) ? st->sd_label : "");
  } else {
    (void)snprintf(buf, sizeof(buf), "%lu %s (image)", sd_sz, sd_u);
  }
  cy = priv_kv_row(surface, x, cy, "sd", buf, (uint16_t)k_ovl_text);
  return cy;
}

RA8_INTERNAL static uint32_t internal_console_tabs_per_row(int32_t panel_w, uint32_t count)
{
  if (count == 0U) {
    return 1U;
  }
  int32_t per = panel_w / (int32_t)k_con_tab_min_w;
  if (per < 1) {
    per = 1;
  }
  if ((uint32_t)per > count) {
    per = (int32_t)count;
  }
  return (uint32_t)per;
}

RA8_INTERNAL static uint32_t internal_console_tab_row_count(int32_t panel_w, uint32_t count)
{
  if (count == 0U) {
    return 0U;
  }
  const uint32_t per_row = internal_console_tabs_per_row(panel_w, count);
  return (count + per_row - 1U) / per_row;
}

RA8_INTERNAL static void internal_console_tab_rect(int32_t  panel_x,
                                                   int32_t  panel_w,
                                                   uint32_t idx,
                                                   uint32_t count,
                                                   int32_t* r)
{
  if (r == nullptr) {
    return;
  }
  const uint32_t per_row = internal_console_tabs_per_row(panel_w, count);
  const uint32_t row     = idx / per_row;
  const uint32_t col     = idx % per_row;
  const int32_t  pitch   = panel_w / (int32_t)per_row;
  r[0]                   = panel_x + ((int32_t)col * pitch);
  r[1]                   = (int32_t)k_con_y + ((int32_t)row * (int32_t)k_con_tab_h);
  r[2]                   = pitch - (int32_t)k_con_tab_gap;
  r[3]                   = (int32_t)k_con_tab_h - (int32_t)k_con_tab_gap;
  if (r[2] < 0) {
    r[2] = 0;
  }
  if (r[3] < 0) {
    r[3] = 0;
  }
}

RA8_INTERNAL static void internal_draw_console_tabs(board_overlay_surface_t* surface,
                                                    int32_t                  panel_x,
                                                    int32_t                  panel_w,
                                                    const board_status_t*    st)
{
  if (st == nullptr) {
    return;
  }
  uint32_t count = st->console_ch_count;
  if (count > (uint32_t)k_overlay_console_tabs_max) {
    count = (uint32_t)k_overlay_console_tabs_max;
  }
  for (uint32_t i = 0U; i < count; i++) {
    int32_t rect[4] = {0, 0, 0, 0};
    internal_console_tab_rect(panel_x, panel_w, i, count, rect);
    const bool active = (i == st->console_active_ch);
    const bool empty  = (st->console_ch_count_lines[i] == 0U);
    uint16_t   bg     = (uint16_t)k_ovl_tab_off_bg;
    uint16_t   txt    = (uint16_t)k_ovl_tab_off_txt;
    if (active) {
      bg  = (uint16_t)k_ovl_tab_on_bg;
      txt = (uint16_t)k_ovl_tab_on_txt;
    } else if (empty) {
      txt = (uint16_t)k_ovl_tab_empty_txt;
    }
    priv_fill_rect(surface, rect[0], rect[1], rect[2], rect[3], bg);
    enum : uint8_t {
      k_tab_caption_cap = 24U, 
    };
    char        cap[k_tab_caption_cap];
    const char* name = (st->console_ch_name[i] != nullptr) ? st->console_ch_name[i] : "?";
    (void)snprintf(cap, sizeof(cap), "%s %u", name, st->console_ch_count_lines[i]);
    priv_draw_text(surface,
                   rect[0] + (int32_t)k_con_tab_txt,
                   rect[1] + (int32_t)k_con_tab_cap_y,
                   cap,
                   txt,
                   1);
  }
}
 
/* @brief Paint the tabbed console panel (newest line at the bottom). */
RA8_INTERNAL static void
internal_draw_console_heading(board_overlay_surface_t* surface, int32_t x, const board_status_t* st)
{
  enum : uint8_t {
    k_console_head_cap = 80U, 
  };
  char     buf[k_console_head_cap];
  uint16_t head_col;
  if (!st->console_autoscroll) {
    /* Paused: amber heading + how far back the held view sits and how to resume. */
    (void)snprintf(buf,
                   sizeof(buf),
                   "CONSOLE  PAUSED -%u/%u  click=follow",
                   st->console_scroll,
                   st->console_total);
    head_col = (uint16_t)k_ovl_amber;
  } else {
    (void)snprintf(buf, sizeof(buf), "CONSOLE  LIVE  (UART %u B, wheel=scroll)", st->uart_tx_total);
    head_col = (uint16_t)k_ovl_ok;
  }
  priv_draw_text(surface, x, (int32_t)k_con_head_y, buf, head_col, 1);
  priv_fill_rect(surface,
                 x,
                 (int32_t)k_con_head_y + (int32_t)k_rule_dy,
                 (int32_t)k_ovl_sidebar_w - (2 * (int32_t)k_pad_x),
                 1,
                 (uint16_t)k_ovl_rule);
}

RA8_INTERNAL static void internal_draw_console_body(board_overlay_surface_t* surface,
                                                    int32_t                  panel_x,
                                                    int32_t                  body_y,
                                                    int32_t                  body_h,
                                                    const board_status_t*    st)
{
  const int32_t max_rows = (body_h - (2 * (int32_t)k_con_pad)) / (int32_t)k_con_line_h;
  int32_t       rows     = (int32_t)st->console_count;
  if (rows > max_rows) {
    rows = max_rows;
  }
  for (int32_t i = 0; i < rows; i++) {
    /* Bottom row (i=0 from the bottom) is console[0], the newest line. */
    const int32_t  ly  = body_y + body_h - (int32_t)k_con_pad - ((i + 1) * (int32_t)k_con_line_h);
    const uint16_t col = (i == 0) ? (uint16_t)k_ovl_console_new : (uint16_t)k_ovl_console_txt;
    priv_draw_text(surface, panel_x + (int32_t)k_con_pad, ly, st->console[i], col, 1);
  }
}

RA8_INTERNAL static void
internal_draw_console(board_overlay_surface_t* surface, int32_t x, const board_status_t* st)
{
  internal_draw_console_heading(surface, x, st);
  const int32_t panel_x = x;
  const int32_t panel_w = (int32_t)k_ovl_sidebar_w - (2 * (int32_t)k_pad_x);
  const int32_t panel_h = (int32_t)surface->height - (int32_t)k_con_y - (int32_t)k_con_bottom;
  if (panel_h < (int32_t)k_con_line_h) {
    return;
  }
  priv_fill_rect(surface, panel_x, (int32_t)k_con_y, panel_w, panel_h, (uint16_t)k_ovl_console_bg);
  /* The tab bar wraps into as many rows as the channel count needs; the scrolling
   * body fills whatever is left below it. */
  internal_draw_console_tabs(surface, panel_x, panel_w, st);
  uint32_t tab_count = st->console_ch_count;
  if (tab_count > (uint32_t)k_overlay_console_tabs_max) {
    tab_count = (uint32_t)k_overlay_console_tabs_max;
  }
  const int32_t tab_rows = (int32_t)internal_console_tab_row_count(panel_w, tab_count);
  const int32_t tab_band = tab_rows * (int32_t)k_con_tab_h;
  const int32_t body_y   = (int32_t)k_con_y + tab_band;
  const int32_t body_h   = panel_h - tab_band;
  if (body_h < (int32_t)k_con_line_h) {
    return;
  }
  /* Fit as many lines as the body height allows; show the newest at the bottom
   * so the console scrolls upward like a terminal. console[0] is the newest. */
  internal_draw_console_body(surface, panel_x, body_y, body_h, st);
}

RA8_INTERNAL static void
internal_draw_button(board_overlay_surface_t* surface, int32_t x, const char* label, bool pressed)
{
  const uint16_t face = pressed ? (uint16_t)k_ovl_btn_down : (uint16_t)k_ovl_btn_up;
  priv_fill_rect(surface,
                 x - 1,
                 (int32_t)k_btn_y - 1,
                 (int32_t)k_btn_w + 2,
                 (int32_t)k_btn_h + 2,
                 (uint16_t)k_ovl_btn_border);
  priv_fill_rect(surface, x, (int32_t)k_btn_y, (int32_t)k_btn_w, (int32_t)k_btn_h, face);
  priv_draw_text(surface,
                 x + (int32_t)k_btn_label_x,
                 (int32_t)k_btn_y + (int32_t)k_btn_label_y,
                 label,
                 (uint16_t)k_ovl_btn_label,
                 2);
}

RA8_INTERNAL static void
internal_draw_buttons(board_overlay_surface_t* surface, int32_t x, const board_status_t* st)
{
  (void)priv_section_head(surface, x, (int32_t)k_btn_head_y, "BUTTONS  (click)");
  internal_draw_button(surface, x, "SW1", st->sw1_pressed);
  internal_draw_button(surface, x + (int32_t)k_btn_w + (int32_t)k_btn_gap, "SW2", st->sw2_pressed);
}

RA8_INTERNAL static uint8_t internal_battery_clamp(uint8_t soc)
{
  return (soc > (uint8_t)k_pwr_soc_full) ? (uint8_t)k_pwr_soc_full : soc;
}

RA8_INTERNAL static uint16_t internal_battery_fill_color(uint8_t soc, bool charging)
{
  if (charging) {
    return (uint16_t)k_ovl_ok; /* charging always reads green. */
  }
  if (soc <= (uint8_t)k_pwr_soc_low) {
    return (uint16_t)k_ovl_red;
  }
  if (soc <= (uint8_t)k_pwr_soc_mid) {
    return (uint16_t)k_ovl_amber;
  }
  return (uint16_t)k_ovl_ok;
}

RA8_INTERNAL static void
internal_draw_power(board_overlay_surface_t* surface, int32_t x, const board_status_t* st)
{
  (void)priv_section_head(surface, x, (int32_t)k_pwr_head_y, "POWER  (drag)");
  const uint8_t  soc    = internal_battery_clamp(st->battery_soc);
  const int32_t  fill_w = ((int32_t)k_pwr_track_w * (int32_t)soc) / (int32_t)k_pwr_soc_full;
  const uint16_t fill   = internal_battery_fill_color(soc, st->battery_charging);
  /* Slider track: border, dark bed, then the SOC-proportional level fill. */
  priv_fill_rect(surface,
                 x - 1,
                 (int32_t)k_pwr_y - 1,
                 (int32_t)k_pwr_track_w + 2,
                 (int32_t)k_pwr_h + 2,
                 (uint16_t)k_ovl_btn_border);
  priv_fill_rect(surface,
                 x,
                 (int32_t)k_pwr_y,
                 (int32_t)k_pwr_track_w,
                 (int32_t)k_pwr_h,
                 (uint16_t)k_ovl_btn_up);
  priv_fill_rect(surface, x, (int32_t)k_pwr_y, fill_w, (int32_t)k_pwr_h, fill);
  char buf[16];
  (void)snprintf(buf, sizeof(buf), "%u%%", (unsigned)soc);
  priv_draw_text(surface,
                 x + (int32_t)k_btn_label_x,
                 (int32_t)k_pwr_y + (int32_t)k_pwr_label_y,
                 buf,
                 (uint16_t)k_ovl_heading,
                 1);
  /* CHG toggle: green "CHG +" while charging, dim "BATT" on battery. */
  const int32_t  cx   = x + (int32_t)k_pwr_chg_off;
  const uint16_t face = st->battery_charging ? (uint16_t)k_ovl_btn_down : (uint16_t)k_ovl_btn_up;
  priv_fill_rect(surface,
                 cx - 1,
                 (int32_t)k_pwr_y - 1,
                 (int32_t)k_pwr_chg_w + 2,
                 (int32_t)k_pwr_h + 2,
                 (uint16_t)k_ovl_btn_border);
  priv_fill_rect(surface, cx, (int32_t)k_pwr_y, (int32_t)k_pwr_chg_w, (int32_t)k_pwr_h, face);
  priv_draw_text(surface,
                 cx + (int32_t)k_btn_label_x,
                 (int32_t)k_pwr_y + (int32_t)k_pwr_label_y,
                 st->battery_charging ? "CHG +" : "BATT",
                 (uint16_t)k_ovl_btn_label,
                 1);
}

RA8_INTERNAL static void
internal_draw_core(board_overlay_surface_t* surface, int32_t x, const board_status_t* st)
{
  const int32_t  lx   = x + (int32_t)k_core_lp_off;
  const uint16_t face = st->low_power ? (uint16_t)k_ovl_btn_down : (uint16_t)k_ovl_btn_up;
  priv_fill_rect(surface,
                 lx - 1,
                 (int32_t)k_btn_y - 1,
                 (int32_t)k_core_lp_w + 2,
                 (int32_t)k_btn_h + 2,
                 (uint16_t)k_ovl_btn_border);
  priv_fill_rect(surface, lx, (int32_t)k_btn_y, (int32_t)k_core_lp_w, (int32_t)k_btn_h, face);
  char cbuf[16];
  (void)snprintf(cbuf,
                 sizeof(cbuf),
                 "%s %s",
                 st->core_is_m33 ? "M33" : "M85",
                 st->low_power ? "LP" : "FULL");
  priv_draw_text(surface,
                 lx + (int32_t)k_btn_label_x,
                 (int32_t)k_btn_y + (int32_t)k_btn_label_y,
                 cbuf,
                 (uint16_t)k_ovl_btn_label,
                 1);
}

bool board_overlay_draw_sidebar(board_overlay_surface_t* surface,
                                uint16_t                 panel_w,
                                const board_status_t*    st)
{
  if ((surface == nullptr) || !surface->ok || (surface->fill == nullptr) || (panel_w == 0U) ||
      (surface->width != board_overlay_total_width(panel_w)) ||
      (surface->height < board_overlay_total_height(1U))) {
    return false;
  }
  priv_fill_rect(surface,
                 (int32_t)panel_w,
                 0,
                 (int32_t)k_ovl_sidebar_w,
                 (int32_t)surface->height,
                 (uint16_t)k_ovl_bg);
  priv_fill_rect(surface,
                 (int32_t)panel_w,
                 0,
                 3,
                 (int32_t)surface->height,
                 (uint16_t)k_ovl_divider);
  if (st == nullptr) {
    return surface->ok;
  }
  const int32_t x = (int32_t)panel_w + (int32_t)k_pad_x;
  int32_t       y = k_sidebar_top;
  /* Title bar: a filled accent band with the board name at 2x scale. */
  priv_fill_rect(surface,
                 (int32_t)panel_w + 3,
                 0,
                 (int32_t)k_ovl_sidebar_w - 3,
                 (int32_t)k_title_bar_h,
                 (uint16_t)k_ovl_bg_alt);
  priv_draw_text(surface, x, y, "EK-RA8D2  EMULATOR", (uint16_t)k_ovl_accent, 2);
  y = (int32_t)k_title_bar_h + (int32_t)k_section_gap;
  priv_draw_text(surface,
                 x,
                 y,
                 (st->app_name != nullptr) ? st->app_name : "",
                 (uint16_t)k_ovl_heading,
                 1);
  y += (int32_t)k_title_gap;
  /* The RUN and LEDS sections sit on the upper sidebar; the layout below them
   * (I/O, BUTTONS, CONSOLE) uses fixed Y anchors so the console always fills the
   * bottom regardless of panel height. */
  y = internal_draw_run_stats(surface, x, y, st);
  y += (int32_t)k_section_gap;
  (void)internal_draw_leds(surface, x, y, st);
  (void)internal_draw_io_block(surface, x, (int32_t)k_io_head_y, st);
  internal_draw_power(surface, x, st);
  internal_draw_core(surface, x, st);
  internal_draw_buttons(surface, x, st);
  internal_draw_console(surface, x, st);
  return surface->ok;
}
 
void board_overlay_compose(uint16_t*             out,
                           const uint16_t*       panel,
                           uint16_t              panel_w,
                           uint16_t              panel_h,
                           const board_status_t* st)
{
  if ((out == nullptr) || (panel_w == 0U)) {
    return;
  }
  const uint16_t w = board_overlay_total_width(panel_w);
  const uint16_t h = board_overlay_total_height(panel_h);
  priv_blit_panel(out, w, h, panel, panel_w, panel_h);
  overlay_memory_context_t memory  = {.pixels = out, .stride = w};
  board_overlay_surface_t  surface = {.context = &memory,
                                      .fill    = internal_memory_fill,
                                      .width   = w,
                                      .height  = h,
                                      .ok      = true};
  (void)board_overlay_draw_sidebar(&surface, panel_w, st);
}
 
board_overlay_btn_t board_overlay_hit_button(uint16_t x, uint16_t y, uint16_t panel_w)
{
  const int32_t cx       = (int32_t)x;
  const int32_t cy       = (int32_t)y;
  const int32_t side_lo  = (int32_t)panel_w;
  const int32_t side_hi  = (int32_t)panel_w + (int32_t)k_ovl_sidebar_w;
  const bool    in_sidex = (cx >= side_lo) && (cx < side_hi);
  /* SW1 / SW2 push-buttons. */
  if ((cy >= (int32_t)k_btn_y) && (cy < ((int32_t)k_btn_y + (int32_t)k_btn_h))) {
    const int32_t bx1 = (int32_t)panel_w + (int32_t)k_btn_x_dx;
    if ((cx >= bx1) && (cx < (bx1 + (int32_t)k_btn_w))) {
      return k_board_overlay_btn_sw1;
    }
    const int32_t bx2 = bx1 + (int32_t)k_btn_w + (int32_t)k_btn_gap;
    if ((cx >= bx2) && (cx < (bx2 + (int32_t)k_btn_w))) {
      return k_board_overlay_btn_sw2;
    }
  }
  /* POWER row: the battery slider track and the CHG toggle share one row. */
  if ((cy >= (int32_t)k_pwr_y) && (cy < ((int32_t)k_pwr_y + (int32_t)k_pwr_h))) {
    const int32_t sx = (int32_t)panel_w + (int32_t)k_pwr_x_dx;
    if ((cx >= sx) && (cx < (sx + (int32_t)k_pwr_track_w))) {
      return k_board_overlay_btn_battery;
    }
    const int32_t cgx = sx + (int32_t)k_pwr_chg_off;
    if ((cx >= cgx) && (cx < (cgx + (int32_t)k_pwr_chg_w))) {
      return k_board_overlay_btn_batt_chg;
    }
  }
  /* Core / low-power toggle: shares the BUTTONS row, right of SW1/SW2. */
  if ((cy >= (int32_t)k_btn_y) && (cy < ((int32_t)k_btn_y + (int32_t)k_btn_h))) {
    const int32_t lx = (int32_t)panel_w + (int32_t)k_btn_x_dx + (int32_t)k_core_lp_off;
    if ((cx >= lx) && (cx < (lx + (int32_t)k_core_lp_w))) {
      return k_board_overlay_btn_lowpower;
    }
  }
  /* Console region (heading + panel): a click toggles autoscroll / jumps live,
   * like clicking the Arduino Serial Monitor's pane. */
  if (in_sidex && (cy >= (int32_t)k_con_head_y)) {
    return k_board_overlay_btn_console;
  }
  return k_board_overlay_btn_none;
}
 
bool board_overlay_battery_pct_at(uint16_t x, uint16_t panel_w, uint8_t* out_pct)
{
  if (out_pct == nullptr) {
    return false;
  }
  const int32_t cx = (int32_t)x;
  const int32_t sx = (int32_t)panel_w + (int32_t)k_pwr_x_dx;
  if (cx <= sx) {
    *out_pct = 0U;
  } else if (cx >= (sx + (int32_t)k_pwr_track_w)) {
    *out_pct = (uint8_t)k_pwr_soc_full;
  } else {
    *out_pct = (uint8_t)(((cx - sx) * (int32_t)k_pwr_soc_full) / (int32_t)k_pwr_track_w);
  }
  return true;
}
 
bool board_overlay_hit_console_tab(uint16_t  x,
                                   uint16_t  y,
                                   uint16_t  panel_w,
                                   uint32_t  tab_count,
                                   uint32_t* out_idx)
{
  if (out_idx == nullptr) {
    return false;
  }
  if (tab_count == 0U) {
    return false;
  }
  uint32_t count = tab_count;
  if (count > (uint32_t)k_overlay_console_tabs_max) {
    count = (uint32_t)k_overlay_console_tabs_max;
  }
  const int32_t cx       = (int32_t)x;
  const int32_t cy       = (int32_t)y;
  const int32_t origin_x = (int32_t)panel_w + (int32_t)k_pad_x;
  const int32_t pan_w    = (int32_t)k_ovl_sidebar_w - (2 * (int32_t)k_pad_x);
  /* Point-in-cell test against the wrapping grid: each cell carries its own
   * row y, so a click resolves to the right tab on any row. The four bounds are
   * split into separate guards (no compound decision) so each edge is its own
   * branch. */
  for (uint32_t i = 0U; i < count; i++) {
    int32_t rect[4] = {0, 0, 0, 0};
    internal_console_tab_rect(origin_x, pan_w, i, count, rect);
    if (cx < rect[0]) {
      continue;
    }
    if (cx >= (rect[0] + rect[2])) {
      continue;
    }
    if (cy < rect[1]) {
      continue;
    }
    if (cy >= (rect[1] + rect[3])) {
      continue;
    }
    *out_idx = i;
    return true;
  }
  return false;
}