main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.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_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_touch.h"
#include "ra8_touch_cal.h"

typedef enum : uint16_t {
  k_tc_fb_w       = 512U, 
  k_tc_fb_h       = 512U, 
  k_tc_inset_px   = 40U,  
  k_tc_cross_half = 12U,  
  k_tc_verify_tol = 2U,   
} tc_geom_t;

typedef enum : uint16_t {
  k_tc_color_bg        = 0x0000U, 
  k_tc_color_target    = 0xFFFFU, 
  k_tc_color_corrected = 0x07E0U, 
} tc_color_t;

typedef enum : uint32_t {
  k_tc_uart_baud  = 115200U, 
  k_tc_max_points = 5U,      
  k_tc_poll_max   = 20000U,  
  k_tc_dec_ten    = 10U,     
  k_tc_blob_cap   = 36U,     
} tc_consts_t;

typedef struct {
  display_handle_t*     disp;                               
  ra8_touch_cal_point_t targets[k_ra8_touch_cal_n_targets]; 
  ra8_touch_cal_point_t raws[k_ra8_touch_cal_n_targets];    
  uint8_t               n_drawn;                            
  uint8_t               n_read;                             
} tc_capture_t;

[[gnu::aligned(k_ra8_board_fb_align_bytes)]] static uint16_t
  s_framebuffer[(uint32_t)k_tc_fb_w * (uint32_t)k_tc_fb_h];

static tc_capture_t s_capture;

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

static const uint8_t s_tc_msg_boot[] = "touchcal: boot\r\n";
static const uint8_t s_tc_msg_fail_in[] = "touchcal: FAIL init\r\n";
static const uint8_t s_tc_msg_fail_gl[] = "touchcal: FAIL glcdc\r\n";
static const uint8_t s_tc_msg_fail_op[] = "touchcal: FAIL open\r\n";
static const uint8_t s_tc_msg_tgt[] = "touchcal: target ";
static const uint8_t s_tc_msg_cal_ok[] = "touchcal: cal=OK verify=";
static const uint8_t s_tc_msg_ok[] = "OK";
static const uint8_t s_tc_msg_bad[] = "FAIL";
static const uint8_t s_tc_msg_maxerr[] = " maxerr=";
static const uint8_t s_tc_msg_skip[] = "touchcal: cal=SKIP got=";
static const uint8_t s_tc_msg_ready[] = "touchcal: ready dim=512x512\r\n";
static const uint8_t s_tc_msg_comma[] = ",";
static const uint8_t s_tc_msg_eol[] = "\r\n";
 
/* ===========================================================================
 * Console
 * ===========================================================================
 */

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

RA8_INTERNAL static void internal_tc_panic_halt(const uint8_t* msg, uint32_t len)
{
  internal_tc_print(msg, len);
  __asm__ volatile("bkpt #0");
  while (1) {
    __asm__ volatile("wfi");
  }
}

RA8_INTERNAL static void internal_tc_print_uint(uint32_t value)
{
  uint8_t  buf[k_tc_dec_ten];
  uint32_t n = 0U;
  if (value == 0U) {
    buf[n] = (uint8_t)'0';
    n++;
  }
  while ((value > 0U) && (n < (uint32_t)k_tc_dec_ten)) {
    buf[n] = (uint8_t)('0' + (value % (uint32_t)k_tc_dec_ten));
    n++;
    value /= (uint32_t)k_tc_dec_ten;
  }
  for (uint32_t i = 0U; i < n; i++) {
    internal_tc_print(&buf[n - 1U - i], 1U);
  }
}
 
/* ===========================================================================
 * Framebuffer cross-hair painting
 * ===========================================================================
 */

RA8_INTERNAL static bool internal_tc_pixel_in_bounds(int32_t v, int32_t dim)
{
  return (v >= 0) && (v < dim);
}

RA8_INTERNAL static void internal_tc_put_px(int32_t x, int32_t y, uint16_t color)
{
  if (internal_tc_pixel_in_bounds(x, (int32_t)k_tc_fb_w) &&
      internal_tc_pixel_in_bounds(y, (int32_t)k_tc_fb_h)) {
    s_framebuffer[((uint32_t)y * (uint32_t)k_tc_fb_w) + (uint32_t)x] = color;
  }
}

RA8_INTERNAL static void internal_tc_fb_fill(uint16_t color)
{
  for (uint32_t i = 0U; i < (uint32_t)k_tc_fb_w * (uint32_t)k_tc_fb_h; i++) {
    s_framebuffer[i] = color;
  }
}

RA8_INTERNAL static void internal_tc_draw_cross(int32_t cx, int32_t cy, uint16_t color)
{
  const int32_t half = (int32_t)k_tc_cross_half;
  for (int32_t d = -half; d <= half; d++) {
    internal_tc_put_px(cx + d, cy, color);
    internal_tc_put_px(cx, cy + d, color);
  }
}
 
/* ===========================================================================
 * GLCDC + touch bring-up
 * ===========================================================================
 */

RA8_INTERNAL static void internal_tc_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if ((ra8_cgc_init() != k_ra8_ok) || (ra8_mstp_init() != k_ra8_ok)) {
    internal_tc_panic_halt(s_tc_msg_fail_in, (uint32_t)sizeof(s_tc_msg_fail_in) - 1U);
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    internal_tc_panic_halt(s_tc_msg_fail_in, (uint32_t)sizeof(s_tc_msg_fail_in) - 1U);
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    internal_tc_panic_halt(s_tc_msg_fail_in, (uint32_t)sizeof(s_tc_msg_fail_in) - 1U);
  }
  if (ra8_board_uart_console_init((uint32_t)k_tc_uart_baud) != k_ra8_ok) {
    internal_tc_panic_halt(s_tc_msg_fail_in, (uint32_t)sizeof(s_tc_msg_fail_in) - 1U);
  }
}

RA8_INTERNAL static bool internal_tc_glcdc_bringup(display_handle_t** out_disp)
{
  internal_tc_fb_fill((uint16_t)k_tc_color_bg);
  display_handle_t* d = nullptr;
  if (display_init(&s_tc_display_cfg, &d) != k_ra8_ok) {
    return false;
  }
  if (d == nullptr) {
    return false;
  }
  display_fb_t fb = {};
  if (display_get_framebuffer(d, &fb) != k_ra8_ok) {
    return false;
  }
  if (fb.pixels != (void*)s_framebuffer) {
    return false;
  }
  *out_disp = d;
  return true;
}

RA8_INTERNAL static bool internal_tc_touch_bringup(void)
{
  const ra8_board_touch_cfg_t cfg = {.max_points = (uint8_t)k_tc_max_points,
                                     .irq_pin    = (uint8_t)k_ra8_touch_irq_pin_unset};
  return ra8_board_touch_open(&cfg) == k_ra8_ok;
}
 
/* ===========================================================================
 * Calibration shims (SOLID-D seams inverted onto by ra8_touch_cal_run)
 * ===========================================================================
 */

RA8_INTERNAL static ra8_err_t internal_tc_draw_target(void* ctx, ra8_touch_cal_point_t target)
{
  tc_capture_t* cap = (tc_capture_t*)ctx;
  if ((cap == nullptr) || (cap->n_drawn >= (uint8_t)k_ra8_touch_cal_n_targets)) {
    return k_ra8_err_invalid_arg;
  }
  cap->targets[cap->n_drawn] = target;
  cap->n_drawn++;
  internal_tc_draw_cross(target.x, target.y, (uint16_t)k_tc_color_target);
  if (cap->disp != nullptr) {
    (void)display_flush(cap->disp, display_full_rect(cap->disp), k_display_refresh_fast);
  }
  internal_tc_print(s_tc_msg_tgt, (uint32_t)sizeof(s_tc_msg_tgt) - 1U);
  internal_tc_print_uint((uint32_t)target.x);
  internal_tc_print(s_tc_msg_comma, (uint32_t)sizeof(s_tc_msg_comma) - 1U);
  internal_tc_print_uint((uint32_t)target.y);
  internal_tc_print(s_tc_msg_eol, (uint32_t)sizeof(s_tc_msg_eol) - 1U);
  return k_ra8_ok;
}

RA8_INTERNAL static bool internal_tc_sample_usable(ra8_err_t rc, uint8_t got)
{
  return (rc == k_ra8_ok) && (got >= 1U);
}

RA8_INTERNAL static ra8_err_t internal_tc_read_raw(void* ctx, ra8_touch_cal_point_t* out_raw)
{
  tc_capture_t* cap = (tc_capture_t*)ctx;
  if ((cap == nullptr) || (out_raw == nullptr) ||
      (cap->n_read >= (uint8_t)k_ra8_touch_cal_n_targets)) {
    return k_ra8_err_invalid_arg;
  }
  ra8_touch_point_t pts[k_tc_max_points] = {};
  for (uint32_t i = 0U; i < (uint32_t)k_tc_poll_max; i++) {
    uint8_t         got = 0U;
    const ra8_err_t rc  = ra8_touch_read(pts, (uint8_t)k_tc_max_points, &got);
    if (internal_tc_sample_usable(rc, got)) {
      out_raw->x             = (int32_t)pts[0].x;
      out_raw->y             = (int32_t)pts[0].y;
      cap->raws[cap->n_read] = *out_raw;
      cap->n_read++;
      return k_ra8_ok;
    }
  }
  return k_ra8_err_hw_error;
}
 
/* ===========================================================================
 * Verify pass
 * ===========================================================================
 */

RA8_INTERNAL static int32_t internal_tc_axis_err(int32_t a, int32_t b)
{
  const int32_t d = a - b;
  return (d < 0) ? -d : d;
}

RA8_INTERNAL static bool
internal_tc_cal_pass(ra8_err_t run_rc, int32_t maxerr, int32_t tol, bool blob_ok)
{
  return (run_rc == k_ra8_ok) && (maxerr <= tol) && blob_ok;
}

RA8_INTERNAL static bool internal_tc_blob_roundtrip(const ra8_touch_cal_matrix_t* m)
{
  uint8_t                blob0[k_tc_blob_cap] = {};
  uint8_t                blob1[k_tc_blob_cap] = {};
  ra8_touch_cal_matrix_t back                 = {};
  if (ra8_touch_cal_save(m, blob0, sizeof(blob0)) != k_ra8_ok) {
    return false;
  }
  if (ra8_touch_cal_load(blob0, sizeof(blob0), &back) != k_ra8_ok) {
    return false;
  }
  if (ra8_touch_cal_save(&back, blob1, sizeof(blob1)) != k_ra8_ok) {
    return false;
  }
  return memcmp(blob0, blob1, sizeof(blob0)) == 0;
}

RA8_INTERNAL static ra8_err_t
internal_tc_apply_and_measure(const ra8_touch_cal_matrix_t* m, tc_capture_t* cap, int32_t* out_max)
{
  if ((m == nullptr) || (cap == nullptr) || (out_max == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  int32_t worst = 0;
  for (uint8_t i = 0U; i < cap->n_read; i++) {
    ra8_touch_cal_point_t screen = {};
    const ra8_err_t       rc =
      ra8_touch_cal_apply(cap->raws[i], m, (uint16_t)k_tc_fb_w, (uint16_t)k_tc_fb_h, &screen);
    if (rc != k_ra8_ok) {
      return rc;
    }
    const int32_t ex = internal_tc_axis_err(screen.x, cap->targets[i].x);
    const int32_t ey = internal_tc_axis_err(screen.y, cap->targets[i].y);
    worst            = (ex > worst) ? ex : worst;
    worst            = (ey > worst) ? ey : worst;
    internal_tc_draw_cross(screen.x, screen.y, (uint16_t)k_tc_color_corrected);
  }
  if (cap->disp != nullptr) {
    (void)display_flush(cap->disp, display_full_rect(cap->disp), k_display_refresh_fast);
  }
  *out_max = worst;
  return k_ra8_ok;
}
 
/* ===========================================================================
 * Calibration orchestration + result banner
 * ===========================================================================
 */

RA8_INTERNAL static ra8_err_t internal_tc_run_calibration(display_handle_t*       disp,
                                                          ra8_touch_cal_matrix_t* out_matrix)
{
  s_capture                         = (tc_capture_t){};
  s_capture.disp                    = disp;
  const ra8_touch_cal_run_cfg_t cfg = {
    .screen_width  = (uint16_t)k_tc_fb_w,
    .screen_height = (uint16_t)k_tc_fb_h,
    .inset_px      = (uint16_t)k_tc_inset_px,
    .draw_target   = internal_tc_draw_target,
    .draw_ctx      = &s_capture,
    .read_raw      = internal_tc_read_raw,
    .read_ctx      = &s_capture,
  };
  return ra8_touch_cal_run(&cfg, out_matrix);
}

RA8_INTERNAL static void internal_tc_report_ok(int32_t maxerr, bool verify_ok)
{
  internal_tc_print(s_tc_msg_cal_ok, (uint32_t)sizeof(s_tc_msg_cal_ok) - 1U);
  if (verify_ok) {
    internal_tc_print(s_tc_msg_ok, (uint32_t)sizeof(s_tc_msg_ok) - 1U);
  } else {
    internal_tc_print(s_tc_msg_bad, (uint32_t)sizeof(s_tc_msg_bad) - 1U);
  }
  internal_tc_print(s_tc_msg_maxerr, (uint32_t)sizeof(s_tc_msg_maxerr) - 1U);
  internal_tc_print_uint((uint32_t)maxerr);
  internal_tc_print(s_tc_msg_eol, (uint32_t)sizeof(s_tc_msg_eol) - 1U);
}

RA8_INTERNAL static void internal_tc_report_skip(uint8_t got)
{
  internal_tc_print(s_tc_msg_skip, (uint32_t)sizeof(s_tc_msg_skip) - 1U);
  internal_tc_print_uint((uint32_t)got);
  internal_tc_print(s_tc_msg_eol, (uint32_t)sizeof(s_tc_msg_eol) - 1U);
}

RA8_INTERNAL static void internal_tc_calibrate_and_report(display_handle_t* disp)
{
  ra8_touch_cal_matrix_t matrix = {};
  const ra8_err_t        run_rc = internal_tc_run_calibration(disp, &matrix);
  if (run_rc != k_ra8_ok) {
    internal_tc_report_skip(s_capture.n_read);
    return;
  }
  int32_t maxerr = 0;
  if (internal_tc_apply_and_measure(&matrix, &s_capture, &maxerr) != k_ra8_ok) {
    internal_tc_report_ok(maxerr, false);
    return;
  }
  const bool blob_ok   = internal_tc_blob_roundtrip(&matrix);
  const bool verify_ok = internal_tc_cal_pass(run_rc, maxerr, (int32_t)k_tc_verify_tol, blob_ok);
  internal_tc_report_ok(maxerr, verify_ok);
}
 
/* ===========================================================================
 * Boot + main
 * ===========================================================================
 */

void main(void)
{
  internal_tc_setup_or_halt();
  ra8_isr_globals_enable();
  internal_tc_print(s_tc_msg_boot, (uint32_t)sizeof(s_tc_msg_boot) - 1U);
 
  display_handle_t* disp = nullptr;
  if (!internal_tc_glcdc_bringup(&disp)) {
    internal_tc_panic_halt(s_tc_msg_fail_gl, (uint32_t)sizeof(s_tc_msg_fail_gl) - 1U);
  }
  if (!internal_tc_touch_bringup()) {
    internal_tc_panic_halt(s_tc_msg_fail_op, (uint32_t)sizeof(s_tc_msg_fail_op) - 1U);
  }
 
  internal_tc_calibrate_and_report(disp);
 
  /* Finger-free bring-up sentinel: prints in every environment (bench + EIL),
   * so hil.conf asserts this line and lets the negative set catch a solver
   * regression (verify=FAIL / cal=FAIL). */
  internal_tc_print(s_tc_msg_ready, (uint32_t)sizeof(s_tc_msg_ready) - 1U);
 
  while (1) {
    __asm__ volatile("wfi");
  }
}