main.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "cam_ceu.h"
#include "cam_image.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_camera.h"
#include "ra8_camera_source_ceu.h"
#include "ra8_ceu.h"
#include "ra8_cgc.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_gpt.h"
#include "ra8_i2c.h"
#include "ra8_isr.h"
#include "ra8_mstp.h"
#include "ra8_ov5640.h"
#include "ra8_port_utils.h"
#include "ra8_sdramc.h"
#include "ra8_time.h"
 
/* =============================================================================
 * Tunable constants (typed enums -- no magic numbers)
 * =============================================================================
 */

typedef enum : uint32_t {
  k_cam_baud            = 115200U,   
  k_cam_xclk_hz         = 24000000U, 
  k_cam_mode_settle_ms  = 100U,      
  k_cam_capture_poll_ms = 5U,        
  k_cam_capture_tries   = 800U,      
  k_cam_cache_line      = 32U,       
  k_cam_string_cap      = 1024U,     
  k_cam_dec_cap         = 99999999U, 
  k_cam_gpt_probe_iters = 64U,       
} cam_u32_t;

typedef enum : uint8_t {
  k_cam_nibble_mask = 0x0FU, 
  k_cam_dec_base    = 10U,   
  k_cam_byte_max    = 0xFFU, 
  k_cam_scan_lo     = 0x08U, 
  k_cam_scan_hi     = 0x77U, 
} cam_u8_t;

typedef enum : uint16_t {
  k_cam_line_bytes = 1280U, 
} cam_capture_geom_t;

typedef enum : uint8_t {
  k_cam_bytes_per_pixel = 2U, 
} cam_capture_layout_t;

typedef enum : uint8_t {
  k_cam_xclk_gpt_ch = 12U, 
} cam_gpt_t;
 
/* =============================================================================
 * J-Link-probable result globals
 * =============================================================================
 */

volatile uint32_t g_cam_chipid = 0U;
volatile uint32_t g_cam_frame_ok = 0U;
volatile uint32_t g_cam_min = 0U;
volatile uint32_t g_cam_max = 0U;
volatile uint32_t g_cam_mean = 0U;
volatile uint32_t g_cam_verdict = 0U;

static const uint8_t k_cam_tag[] = "cam: ";

static ra8_ov5640_t s_camera_sensor;

static ra8_camera_source_t           s_camera_source;
static ra8_camera_source_ceu_state_t s_camera_source_state;

static ra8_camera_frame_t s_camera_frame;

alignas(k_cam_cache_line) static uint8_t s_camera_capture[k_cam_uyvy_frame_bytes];

static ra8_err_t cam_sensor_bind(void)
{
  const ra8_ov5640_bus_t bus = {
    .read_reg  = ra8_board_camera_sccb_read_reg,
    .write_reg = ra8_board_camera_sccb_write_reg,
    .delay_ms  = ra8_board_camera_delay_ms,
    .ctx       = nullptr,
  };
  return ra8_ov5640_init(&s_camera_sensor, &bus);
}

static ra8_err_t cam_capture_source_bind(void)
{
  const ra8_camera_source_ceu_cfg_t cfg = {
    .ceu =
      {
        .width_px        = (uint16_t)k_cam_image_width_px,
        .height_px       = (uint16_t)k_cam_image_height_px,
        .x_start_px      = 0U,
        .y_start_px      = 0U,
        .x_capture_px    = (uint16_t)k_cam_line_bytes,
        .y_capture_lines = (uint16_t)k_cam_image_height_px,
        .dst_stride      = (uint16_t)k_cam_line_bytes,
        .frame_drop      = 0U,
        .bytes_per_pixel = (uint8_t)k_cam_bytes_per_pixel,
        .interrupts      = 0U,
        .capture_format  = k_ra8_ceu_fmt_data_synchronous,
        .capture_mode    = k_ra8_ceu_capture_single,
        .data_bus        = k_ra8_ceu_bus_8_bit,
        .hsync_polarity  = k_ra8_ceu_pol_high_active,
        .vsync_polarity  = k_ra8_ceu_pol_high_active,
        .field_polarity  = k_ra8_ceu_pol_high_active,
        .input_order     = k_ra8_ceu_input_cb0_y0_cr0_y1,
        .output_format   = k_ra8_ceu_output_ycbcr_422,
        .burst_mode      = k_ra8_ceu_burst_32,
        .first_field     = k_ra8_ceu_field_immediate,
        .edge            = {k_ra8_ceu_edge_rising,
                            k_ra8_ceu_edge_rising,
                            k_ra8_ceu_edge_rising,
                            k_ra8_ceu_edge_rising},
        .byte_swap       = {false, true, true},
        .scale = {0U, 0U, 0U, 0U, (uint16_t)k_cam_image_width_px, (uint16_t)k_cam_image_height_px},
        .interlace       = false,
        .one_field_only  = false,
        .bundle_write    = false,
        .low_pass_filter = false,
        .image_area_size = 0U,
      },
    .output =
      {
        .frame_bytes_max = (uint32_t)k_cam_uyvy_frame_bytes,
        .stride_bytes    = (uint32_t)k_cam_line_bytes,
        .width           = (uint16_t)k_cam_image_width_px,
        .height          = (uint16_t)k_cam_image_height_px,
        .format          = k_ra8_camera_format_uyvy422,
      },
    .poll_interval_ms = (uint32_t)k_cam_capture_poll_ms,
    .poll_attempts    = (uint32_t)k_cam_capture_tries,
  };
  return ra8_camera_source_ceu_init(&s_camera_source, &s_camera_source_state, &cfg);
}
 
/* =============================================================================
 * Console helpers
 * =============================================================================
 */

static uint32_t cam_strlen(const char* s)
{
  RA8_CHECK_NULL_PTR(s, "cam", "strlen");
  uint32_t n = 0U;
  while ((n < (uint32_t)k_cam_string_cap) && (s[n] != '\0')) {
    n += 1U;
  }
  return n;
}

static ra8_err_t cam_puts(const char* s)
{
  RA8_CHECK_NULL_PTR(s, "cam", "puts");
  const uint32_t len = cam_strlen(s);
  return ra8_board_uart_console_write((const uint8_t*)s, (size_t)len);
}

static ra8_err_t cam_put_hex(uint32_t value, uint8_t width)
{
  static const char k_hex[] = "0123456789ABCDEF";
  RA8_CHECK_RANGE(width, 1U, 8U, k_ra8_err_invalid_arg);
  char     buf[8];
  uint8_t  i = width;
  uint32_t v = value;
  while (i > 0U) {
    i      = (uint8_t)(i - 1U);
    buf[i] = k_hex[v & (uint32_t)k_cam_nibble_mask];
    v >>= 4U;
  }
  return ra8_board_uart_console_write((const uint8_t*)buf, (size_t)width);
}

static ra8_err_t cam_put_u32(uint32_t value)
{
  if (value > (uint32_t)k_cam_dec_cap) {
    return k_ra8_err_invalid_arg;
  }
  char     buf[8];
  uint8_t  i = (uint8_t)sizeof(buf);
  uint32_t v = value;
  do {
    i      = (uint8_t)(i - 1U);
    buf[i] = (char)('0' + (v % (uint32_t)k_cam_dec_base));
    v /= (uint32_t)k_cam_dec_base;
  } while ((v != 0U) && (i > 0U));
  const uint32_t len = (uint32_t)((uint8_t)sizeof(buf) - i);
  return ra8_board_uart_console_write((const uint8_t*)&buf[i], (size_t)len);
}
 
/* =============================================================================
 * Frame plausibility
 * =============================================================================
 */

static bool cam_frame_is_plausible(const ra8_camera_frame_t* frame)
{
  if ((frame == nullptr) || (frame->data == nullptr)) {
    return false;
  }
  if ((frame->bytes != (uint32_t)k_cam_uyvy_frame_bytes) ||
      (frame->stride_bytes != (uint32_t)k_cam_line_bytes)) {
    return false;
  }
  if ((frame->width != (uint16_t)k_cam_image_width_px) ||
      (frame->height != (uint16_t)k_cam_image_height_px)) {
    return false;
  }
  if (frame->format != k_ra8_camera_format_uyvy422) {
    return false;
  }
  const uint32_t n   = frame->bytes;
  uint32_t       lo  = (uint32_t)k_cam_byte_max;
  uint32_t       hi  = 0U;
  uint32_t       sum = 0U;
  for (uint32_t i = 0U; i < n; i += 1U) {
    const uint32_t b = (uint32_t)frame->data[i];
    if (b < lo) {
      lo = b;
    }
    if (b > hi) {
      hi = b;
    }
    sum += b;
  }
  g_cam_min  = lo;
  g_cam_max  = hi;
  g_cam_mean = sum / n;
  return hi != lo;
}
 
/* =============================================================================
 * Discovery
 * =============================================================================
 */

static void cam_bus_scan(void)
{
  (void)cam_puts(" scan=");
  for (uint8_t a = (uint8_t)k_cam_scan_lo; a <= (uint8_t)k_cam_scan_hi; a += 1U) {
    bool acked = false;
    if (ra8_i2c_scan((uint8_t)k_ra8_board_camera_i2c_channel, a, &acked) != k_ra8_ok) {
      continue;
    }
    if (!acked) {
      continue;
    }
    (void)cam_put_hex((uint32_t)a, 2U);
    /* Read register 0 (8-bit pointer) as a coarse device-ID fingerprint. */
    const uint8_t reg = 0U;
    uint8_t       v   = 0U;
    if (ra8_i2c_transfer((uint8_t)k_ra8_board_camera_i2c_channel, a, &reg, 1U, &v, 1U) ==
        k_ra8_ok) {
      (void)cam_puts(":");
      (void)cam_put_hex((uint32_t)v, 2U);
    }
    (void)cam_puts(".");
  }
}
 
/* =============================================================================
 * Orchestration
 * =============================================================================
 */

static void cam_park(void)
{
  while (1) {
    __asm__ volatile("wfi");
  }
}

static ra8_err_t cam_bringup(void)
{
  uint32_t  cpuclk0_hz = 0U;
  ra8_err_t err        = ra8_cgc_init();
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz);
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_mstp_init();
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_time_init(cpuclk0_hz);
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_board_uart_console_init((uint32_t)k_cam_baud);
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_sdramc_init();
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_board_camera_xclk_start((uint32_t)k_cam_xclk_hz);
  if (err != k_ra8_ok) {
    return err;
  }
  /* Force only SW4-6 ON so DVP reaches the sensor without overriding the
     physical settings used by unrelated board peripherals. */
  err = ra8_board_camera_select_parallel();
  if (err != k_ra8_ok) {
    return err;
  }
  ra8_delay_ms((uint32_t)k_cam_mode_settle_ms);
  return k_ra8_ok;
}

static void cam_print_hsync_probe(const cam_ceu_sync_probe_t* probe)
{
  (void)cam_puts(" h=");
  (void)cam_put_u32(probe->hsync_high_min);
  (void)cam_puts("-");
  (void)cam_put_u32(probe->hsync_high_max);
  (void)cam_puts(" l=");
  (void)cam_put_u32(probe->hsync_low_min);
  (void)cam_puts("-");
  (void)cam_put_u32(probe->hsync_low_max);
  (void)cam_puts(" hc=");
  (void)cam_put_u32(probe->hsync_high_cycles_min);
  (void)cam_puts("-");
  (void)cam_put_u32(probe->hsync_high_cycles_max);
}

static void cam_print_data_probe(const cam_ceu_sync_probe_t* probe)
{
  (void)cam_puts(" pc=");
  (void)cam_put_u32(probe->pclk_edges);
  (void)cam_puts(" ph=");
  (void)cam_put_u32(probe->pclk_half_cycles_min);
  (void)cam_puts(" data=");
  (void)cam_put_u32(probe->data_samples);
  (void)cam_puts("/");
  (void)cam_put_u32(probe->data_changes);
  (void)cam_puts(" ");
  (void)cam_put_hex((uint32_t)probe->data_min, 2U);
  (void)cam_puts("-");
  (void)cam_put_hex((uint32_t)probe->data_max, 2U);
  (void)cam_puts(" &");
  (void)cam_put_hex((uint32_t)probe->data_and, 2U);
  (void)cam_puts(" |");
  (void)cam_put_hex((uint32_t)probe->data_or, 2U);
}

static void cam_print_line_probe(const cam_ceu_sync_probe_t* probe)
{
  (void)cam_puts(" lineclk=");
  (void)cam_put_u32(probe->measured_lines);
  (void)cam_puts("/");
  (void)cam_put_u32(probe->line_pclk_min);
  (void)cam_puts("-");
  (void)cam_put_u32(probe->line_pclk_max);
  (void)cam_puts("/");
  (void)cam_put_u32(probe->line_pclk_mean);
  (void)cam_puts(" long=");
  (void)cam_put_u32(probe->line_pclk_long);
}

static void cam_print_sync_probe(const cam_ceu_sync_probe_t* probe)
{
  (void)cam_puts(" dvp_sync_edges=");
  (void)cam_put_u32(probe->vsync_edges);
  (void)cam_puts("/");
  (void)cam_put_u32(probe->hsync_edges);
  cam_print_hsync_probe(probe);
  cam_print_data_probe(probe);
  cam_print_line_probe(probe);
}

static ra8_err_t cam_prepare_capture(void)
{
  s_camera_frame = (ra8_camera_frame_t){};
  ra8_err_t err  = ra8_ov5640_configure(&s_camera_sensor, k_ra8_ov5640_mode_vga_uyvy);
  if (err == k_ra8_ok) {
    cam_ceu_sync_probe_t sync_probe = {};
    err                             = cam_probe_sync_activity(&sync_probe);
    cam_print_sync_probe(&sync_probe);
  }
  if (err == k_ra8_ok) {
    err = ra8_board_camera_route_parallel_pins();
  }
  if (err == k_ra8_ok) {
    err = cam_capture_source_bind();
  }
  (void)cam_puts(" ceu=");
  (void)cam_puts((err == k_ra8_ok) ? "OK" : "ERR");
  return err;
}

static bool cam_capture_frame_and_report(bool ready)
{
  bool frame_ok = false;
  if (ready) {
    const ra8_camera_buffer_t capture = {
      .data     = s_camera_capture,
      .capacity = (uint32_t)sizeof(s_camera_capture),
    };
    frame_ok = (ra8_camera_source_capture(&s_camera_source, &capture, &s_camera_frame) == k_ra8_ok);
  }
  g_cam_frame_ok = frame_ok ? 1U : 0U;
  (void)cam_puts(" bytes=");
  (void)cam_put_u32(s_camera_frame.bytes);
  (void)cam_puts(" frame=");
  (void)cam_puts(frame_ok ? "OK" : "ERR");
 
  /* Emit CETCR so missing sync and invalid timing remain diagnosable. */
  uint32_t cetcr = 0U;
  (void)ra8_camera_source_ceu_get_last_events(&s_camera_source_state, &cetcr);
  (void)cam_puts(" cetcr=");
  (void)cam_put_hex(cetcr, 8U);
  return frame_ok;
}

static void cam_finish_verdict(bool frame_ok)
{
  bool plausible = false;
  bool rgb_ok    = false;
  if (frame_ok) {
    plausible = cam_frame_is_plausible(&s_camera_frame);
    if (plausible) {
      rgb_ok = (cam_image_generate(s_camera_frame.data, s_camera_frame.bytes) == k_ra8_ok);
    }
  }
  (void)cam_puts(" min=");
  (void)cam_put_u32(g_cam_min);
  (void)cam_puts(" max=");
  (void)cam_put_u32(g_cam_max);
  (void)cam_puts(" mean=");
  (void)cam_put_u32(g_cam_mean);
  (void)cam_puts(" rgb=");
  (void)cam_puts(rgb_ok ? "OK" : "ERR");
  (void)cam_puts(" rgb_bytes=");
  (void)cam_put_u32(g_cam_rgb_frame_bytes);
  g_cam_verdict = (plausible && rgb_ok) ? 1U : 0U;
  (void)cam_puts((plausible && rgb_ok) ? " verdict=PASS\r\n" : " verdict=FAIL\r\n");
}

static void cam_capture_and_verdict(void)
{
  const ra8_err_t prep_err = cam_prepare_capture();
  const bool      frame_ok = cam_capture_frame_and_report(prep_err == k_ra8_ok);
  cam_finish_verdict(frame_ok);
}

static void cam_run(void)
{
  (void)cam_puts((const char*)k_cam_tag);
 
  /* Confirm the XCLK GPT is actually counting (a proxy that the P501
     XVCLK square wave is live). The GTCNT wraps every few counts at the
     ~24 MHz output rate, so sample it in a tight loop and call it live as
     soon as any read differs from the first; a stuck GTCNT (every sample
     identical) means the sensor never gets a clock. */
  uint32_t cnt_ref     = 0U;
  bool     gpt_running = false;
  (void)ra8_gpt_read((uint8_t)k_cam_xclk_gpt_ch, &cnt_ref);
  for (uint32_t i = 0U; i < (uint32_t)k_cam_gpt_probe_iters; i += 1U) {
    uint32_t cnt = 0U;
    (void)ra8_gpt_read((uint8_t)k_cam_xclk_gpt_ch, &cnt);
    if (cnt != cnt_ref) {
      gpt_running = true;
      break;
    }
  }
  (void)cam_puts(" gpt=");
  (void)cam_puts(gpt_running ? "RUN" : "DEAD");
 
  /* The OV5640 needs XVCLK (up in cam_bringup) and must be out of
     hardware reset before it answers on SCCB, so release RST (P709)
     before scanning and probing the sensor. */
  ra8_err_t rst_err = ra8_board_camera_reset();
  if (rst_err == k_ra8_ok) {
    rst_err = cam_sensor_bind();
  }
 
  cam_bus_scan();
 
  uint16_t   chip = 0U;
  const bool id_ok =
    (rst_err == k_ra8_ok) && (ra8_ov5640_probe(&s_camera_sensor, &chip) == k_ra8_ok);
  g_cam_chipid = (uint32_t)chip;
  (void)cam_puts(" chipid=");
  (void)cam_put_hex((uint32_t)chip, 4U);
  (void)cam_puts(" xclk=OK rst=");
  (void)cam_puts((rst_err == k_ra8_ok) ? "OK" : "ERR");
  (void)cam_puts(" sccb=");
  (void)cam_puts(id_ok ? "OK" : "ERR");
 
  if (!id_ok) {
    (void)cam_puts(" verdict=FAIL\r\n");
    return;
  }
 
  cam_capture_and_verdict();
}

void main(void)
{
  if (cam_bringup() != k_ra8_ok) {
    (void)cam_puts("cam: bringup ERROR verdict=FAIL\r\n");
    cam_park();
    return;
  }
  ra8_isr_globals_enable();
  cam_run();
  cam_park();
}