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_cgc.h"
#include "ra8_display_pal.h"
#include "ra8_display_pal_eink.h"
#include "ra8_epaper.h"
#include "ra8_epd_cal.h"
#include "ra8_err.h"
#include "ra8_io_spi_bus.h"
#include "ra8_io_spi_bus_spi_b.h"
#include "ra8_isr.h"
#include "ra8_mstp.h"
#include "ra8_panel.h"
#include "ra8_port_constants.h"
#include "ra8_port_utils.h"
#include "ra8_spi.h"
#include "ra8_time.h"
 
/* ===========================================================================
 * Compile-time configuration -- typed enums per the no-magic-number rule.
 * =========================================================================== */

typedef enum : uint16_t {
  k_ep_panel_w = 128U, 
  k_ep_panel_h = 128U, 
  k_ep_cell    = 16U,  
} ep_geom_t;

typedef enum : uint16_t {
  k_ep_box_x = 48U, 
  k_ep_box_y = 48U, 
  k_ep_box_w = 32U, 
  k_ep_box_h = 32U, 
} ep_region_t;

typedef enum : uint16_t {
  k_ep_white = 0xFFFFU, 
  k_ep_black = 0x0000U, 
} ep_color_t;

typedef enum : uint32_t {
  k_ep_spi_channel  = 0U,        
  k_ep_spi_baud_hz  = 10000000U, 
  k_ep_uart_baud    = 115200U,   
  k_ep_powerup_ms   = 50U,       
  k_ep_heartbeat_ms = 500U,      
} ep_bus_t;

typedef enum : uint8_t {
  k_ep_line_max   = 48U,  
  k_ep_dec_digits = 10U,  
  k_ep_radix      = 10U,  
  k_ep_cr         = '\r', 
  k_ep_lf         = '\n', 
} ep_fmt_t;

typedef enum : uint16_t {
  k_ep_reset_pin = RA8_PIN(k_ra8_port_4, k_ra8_pin_0), 
  k_ep_hrdy_pin  = RA8_PIN(k_ra8_port_4, k_ra8_pin_1), 
} ep_pin_t;
 
/* ===========================================================================
 * Static storage
 * =========================================================================== */

[[gnu::aligned(k_ra8_board_fb_align_bytes)]] static uint16_t
  s_framebuffer[(uint32_t)k_ep_panel_w * (uint32_t)k_ep_panel_h];

static ra8_io_spi_bus_t s_spi_bus;

static ra8_epaper_cfg_t s_epaper_cfg;

static display_handle_t* s_display = nullptr;

static display_caps_t s_caps;
static display_fb_t   s_fb;

static const uint8_t k_ep_msg_pass[] = "epaper: PASS\r\n";
static const uint8_t k_ep_msg_fail[] = "epaper: FAIL\r\n";

static const uint8_t k_ep_msg_no_vcom[] = "epaper: NO TRUSTED VCOM -- panel left dark\r\n";

typedef enum : uint16_t {
  k_ep_vcom_min_mv = 200U,  
  k_ep_vcom_max_mv = 4000U, 
} ep_vcom_limits_t;
 
/* ===========================================================================
 * Pure helpers (mirrored by tests/mocks/src/test_app_epaper_refresh.c)
 * =========================================================================== */

static uint16_t ep_checker_px(uint16_t x, uint16_t y)
{
  const uint32_t cell = (uint32_t)k_ep_cell;
  const uint32_t sum  = ((uint32_t)x / cell) + ((uint32_t)y / cell);
  return ((sum & 1U) != 0U) ? (uint16_t)k_ep_black : (uint16_t)k_ep_white;
}

static bool ep_region_fits(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint16_t pw, uint16_t ph)
{
  return ((uint32_t)x + (uint32_t)w <= (uint32_t)pw) && ((uint32_t)y + (uint32_t)h <= (uint32_t)ph);
}

static bool ep_flush_ok(ra8_err_t init_err, ra8_err_t full_err, ra8_err_t part_err)
{
  return (init_err == k_ra8_ok) && (full_err == k_ra8_ok) && (part_err == k_ra8_ok);
}

static uint32_t ep_u32_to_dec(uint8_t* buf, uint32_t val)
{
  if (val == 0U) {
    buf[0] = (uint8_t)'0';
    return 1U;
  }
  uint8_t  tmp[k_ep_dec_digits];
  uint32_t n = 0U;
  uint32_t v = val;
  while ((v != 0U) && (n < (uint32_t)k_ep_dec_digits)) {
    tmp[n] = (uint8_t)('0' + (uint8_t)(v % (uint32_t)k_ep_radix));
    v      = v / (uint32_t)k_ep_radix;
    n++;
  }
  for (uint32_t i = 0U; i < n; i++) {
    buf[i] = tmp[n - 1U - i];
  }
  return n;
}
 
/* ===========================================================================
 * Bring-up + reporting
 * =========================================================================== */

static void ep_panic_halt(void)
{
  (void)ra8_board_led_on(k_ra8_board_led_red);
  while (1) {
    __asm__ volatile("wfi");
  }
}

static void ep_emit(const uint8_t* data, uint32_t len)
{
  (void)ra8_board_uart_console_write(data, (size_t)len);
}

static void ep_bringup_core(uint32_t* out_pclka_hz)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    ep_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    ep_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_pclka, out_pclka_hz) != k_ra8_ok) {
    ep_panic_halt();
  }
  if (ra8_mstp_init() != k_ra8_ok) {
    ep_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    ep_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_ep_uart_baud) != k_ra8_ok) {
    ep_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led_blue) != k_ra8_ok) {
    ep_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led_red) != k_ra8_ok) {
    ep_panic_halt();
  }
}

static void ep_bringup_panel_bus(uint32_t pclka_hz)
{
  if (ra8_gpio_output_init((ra8_port_pin_t)k_ep_reset_pin, k_ra8_level_high) != k_ra8_ok) {
    ep_panic_halt();
  }
  if (ra8_gpio_input_init((ra8_port_pin_t)k_ep_hrdy_pin, k_ra8_pull_up) != k_ra8_ok) {
    ep_panic_halt();
  }
 
  const ra8_spi_cfg_t spi_cfg = {
    .baud_hz   = (uint32_t)k_ep_spi_baud_hz,
    .pclka_hz  = pclka_hz,
    .mode      = k_ra8_spi_mode_0,
    .lsb_first = false,
    .loopback  = false,
  };
  if (ra8_spi_init((uint8_t)k_ep_spi_channel, &spi_cfg) != k_ra8_ok) {
    ep_panic_halt();
  }
  if (ra8_io_spi_bus_bind_spi_b(&s_spi_bus, (uint8_t)k_ep_spi_channel) != k_ra8_ok) {
    ep_panic_halt();
  }
 
  ra8_spi_bus_ops_t ops = {};
  if (ra8_io_spi_bus_as_ops(&s_spi_bus, &ops) != k_ra8_ok) {
    ep_panic_halt();
  }
  s_epaper_cfg.bus          = ops;
  s_epaper_cfg.reset_pin    = (uint16_t)k_ep_reset_pin;
  s_epaper_cfg.busy_pin     = (uint16_t)k_ep_hrdy_pin;
  s_epaper_cfg.panel_width  = (uint16_t)k_ep_panel_w;
  s_epaper_cfg.panel_height = (uint16_t)k_ep_panel_h;
  /* Waveform mode numbers are panel data, not driver data: A2 is mode 4 on
   * the M641 LUT (6 inch / 6 inch HD) and mode 6 elsewhere. The descriptor
   * seeds the M641 map so init has a valid one; an app that reaches real
   * hardware should re-derive it from ``ra8_epaper_dev_info().lut_version``
   * once the controller has answered GET_DEV_INFO. */
  if (ra8_epaper_waveform_cfg_for_lut("M641", &s_epaper_cfg.waveform) != k_ra8_ok) {
    ep_panic_halt();
  }
}

static ra8_err_t ep_vcom_get(void* ctx, uint16_t* out_mv)
{
  (void)ctx;
  return ra8_epaper_get_vcom(out_mv);
}

static ra8_err_t ep_vcom_set(void* ctx, uint16_t mv)
{
  (void)ctx;
  return ra8_epaper_set_vcom(mv);
}

static bool ep_calibrate_vcom(void)
{
  const ra8_epd_cal_cfg_t cal_cfg = {
    .limits          = {.min_mv = (uint16_t)k_ep_vcom_min_mv, .max_mv = (uint16_t)k_ep_vcom_max_mv},
    .panel           = {.get = ep_vcom_get, .set = ep_vcom_set, .ctx = nullptr},
    .store           = {.read = nullptr, .write = nullptr, .ctx = nullptr},
    .has_provisioned = false,
    .provisioned_mv  = 0U,
  };
 
  ra8_epd_cal_result_t cal = {};
  if (ra8_epd_cal_resolve(&cal_cfg, &cal) != k_ra8_ok) {
    return false;
  }
  return ra8_epd_cal_apply(&cal_cfg, &cal) == k_ra8_ok;
}

static void ep_paint_checker(void)
{
  uint16_t* px = (uint16_t*)s_fb.pixels;
  for (uint16_t y = 0U; y < s_fb.height_px; ++y) {
    const uint32_t row = (uint32_t)y * (uint32_t)s_fb.width_px;
    for (uint16_t x = 0U; x < s_fb.width_px; ++x) {
      px[row + (uint32_t)x] = ep_checker_px(x, y);
    }
  }
}

static void ep_paint_region_black(void)
{
  uint16_t*      px      = (uint16_t*)s_fb.pixels;
  const uint16_t y_limit = (uint16_t)((uint16_t)k_ep_box_y + (uint16_t)k_ep_box_h);
  const uint16_t x_limit = (uint16_t)((uint16_t)k_ep_box_x + (uint16_t)k_ep_box_w);
  for (uint16_t y = (uint16_t)k_ep_box_y; y < y_limit; ++y) {
    const uint32_t row = (uint32_t)y * (uint32_t)s_fb.width_px;
    for (uint16_t x = (uint16_t)k_ep_box_x; x < x_limit; ++x) {
      px[row + (uint32_t)x] = (uint16_t)k_ep_black;
    }
  }
}

static void ep_report_stage(const char* label, uint32_t dt_ms, uint32_t pixels)
{
  static const uint8_t k_prefix[] = "epaper: ";
  static const uint8_t k_ms_sep[] = " ms=";
  static const uint8_t k_px_sep[] = " px=";
  uint8_t              line[k_ep_line_max];
  uint32_t             pos = 0U;
  for (uint32_t i = 0U; i < (sizeof(k_prefix) - 1U); i++) {
    line[pos++] = k_prefix[i];
  }
  for (uint32_t i = 0U; (label[i] != '\0') && (pos < (uint32_t)k_ep_line_max); i++) {
    line[pos++] = (uint8_t)label[i];
  }
  for (uint32_t i = 0U; i < (sizeof(k_ms_sep) - 1U); i++) {
    line[pos++] = k_ms_sep[i];
  }
  pos += ep_u32_to_dec(&line[pos], dt_ms);
  for (uint32_t i = 0U; i < (sizeof(k_px_sep) - 1U); i++) {
    line[pos++] = k_px_sep[i];
  }
  pos += ep_u32_to_dec(&line[pos], pixels);
  line[pos++] = (uint8_t)k_ep_cr;
  line[pos++] = (uint8_t)k_ep_lf;
  ep_emit(line, pos);
}

static void ep_report_init(void)
{
  static const uint8_t k_prefix[] = "epaper: init ok panel=";
  uint8_t              line[k_ep_line_max];
  uint32_t             pos = 0U;
  for (uint32_t i = 0U; i < (sizeof(k_prefix) - 1U); i++) {
    line[pos++] = k_prefix[i];
  }
  pos += ep_u32_to_dec(&line[pos], (uint32_t)k_ep_panel_w);
  line[pos++] = (uint8_t)'x';
  pos += ep_u32_to_dec(&line[pos], (uint32_t)k_ep_panel_h);
  line[pos++] = (uint8_t)k_ep_cr;
  line[pos++] = (uint8_t)k_ep_lf;
  ep_emit(line, pos);
}

static void ep_run_refresh_cycle(ra8_err_t* full_err, ra8_err_t* part_err)
{
  /* Full refresh: checkerboard + GC16 (quality). */
  ep_paint_checker();
  const uint32_t t0_full = ra8_now_ms();
  *full_err = display_flush(s_display, display_full_rect(s_display), k_display_refresh_quality);
  ep_report_stage("full-refresh",
                  ra8_now_ms() - t0_full,
                  (uint32_t)k_ep_panel_w * (uint32_t)k_ep_panel_h);
 
  /* Partial refresh: blacken a sub-rect + A2 (fast), bounds-checked first. */
  *part_err = k_ra8_err_invalid_arg;
  if (ep_region_fits((uint16_t)k_ep_box_x,
                     (uint16_t)k_ep_box_y,
                     (uint16_t)k_ep_box_w,
                     (uint16_t)k_ep_box_h,
                     (uint16_t)k_ep_panel_w,
                     (uint16_t)k_ep_panel_h)) {
    ep_paint_region_black();
    const display_rect_t box = {
      .x = (uint16_t)k_ep_box_x,
      .y = (uint16_t)k_ep_box_y,
      .w = (uint16_t)k_ep_box_w,
      .h = (uint16_t)k_ep_box_h,
    };
    const uint32_t t0_part = ra8_now_ms();
    *part_err              = display_flush(s_display, box, k_display_refresh_fast);
    ep_report_stage("partial-refresh",
                    ra8_now_ms() - t0_part,
                    (uint32_t)k_ep_box_w * (uint32_t)k_ep_box_h);
  }
}

void main(void)
{
  uint32_t pclka_hz = 0U;
  ep_bringup_core(&pclka_hz);
  ra8_isr_globals_enable();
  ra8_delay_ms((uint32_t)k_ep_powerup_ms);
  ep_bringup_panel_bus(pclka_hz);
 
  const display_cfg_t cfg = {
    .iface             = &k_display_backend_eink_it8951,
    .framebuffer       = s_framebuffer,
    .framebuffer_bytes = sizeof(s_framebuffer),
    .width_px          = (uint16_t)k_ep_panel_w,
    .height_px         = (uint16_t)k_ep_panel_h,
    .pixfmt            = k_display_pixfmt_rgb565,
    .panel_timing      = &s_epaper_cfg,
  };
 
  const ra8_err_t init_err = display_init(&cfg, &s_display);
  if ((init_err != k_ra8_ok) || (display_get_caps(s_display, &s_caps) != k_ra8_ok) ||
      (display_get_framebuffer(s_display, &s_fb) != k_ra8_ok)) {
    ep_emit(k_ep_msg_fail, (uint32_t)(sizeof(k_ep_msg_fail) - 1U));
    ep_panic_halt();
  }
  ep_report_init();
 
  /* INV-VCOM-1: nothing gets refreshed until this panel's own bias has
   * been resolved and confirmed. Deliberately a halt with its own banner
   * rather than a best-effort draw -- a blank screen is a support call,
   * a DC-biased panel is landfill. The driver would refuse the refresh
   * anyway; failing here says why. */
  if (!ep_calibrate_vcom()) {
    ep_emit(k_ep_msg_no_vcom, (uint32_t)(sizeof(k_ep_msg_no_vcom) - 1U));
    ep_panic_halt();
  }
 
  ra8_err_t full_err = k_ra8_err_invalid_arg;
  ra8_err_t part_err = k_ra8_err_invalid_arg;
  ep_run_refresh_cycle(&full_err, &part_err);
 
  (void)display_deinit(s_display); /* sleep the panel */
 
  if (!ep_flush_ok(init_err, full_err, part_err)) {
    ep_emit(k_ep_msg_fail, (uint32_t)(sizeof(k_ep_msg_fail) - 1U));
    ep_panic_halt();
  }
  ep_emit(k_ep_msg_pass, (uint32_t)(sizeof(k_ep_msg_pass) - 1U));
 
  while (1) {
    (void)ra8_board_led_toggle(k_ra8_board_led_blue);
    ra8_delay_ms((uint32_t)k_ep_heartbeat_ms);
  }
}