c6_cam_camera.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "c6_camera_server.h"
#include "ra8_attributes.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_camera.h"
#include "ra8_camera_codec_passthrough.h"
#include "ra8_camera_source_ceu.h"
#include "ra8_ceu.h"
#include "ra8_ov5640.h"
#include "ra8_time.h"
 
typedef enum : uint32_t {
  k_sensor_jpeg_buffer_bytes = 512U * 1024U, 
  k_sensor_jpeg_poll_ms      = 2U,           
  k_sensor_jpeg_poll_tries   = 2000U,        
  k_sensor_jpeg_xclk_hz      = 24000000U,    
  k_sensor_jpeg_settle_ms    = 100U,         
} sensor_jpeg_size_t;
 
typedef enum : uint16_t {
  k_sensor_jpeg_width  = 640U, 
  k_sensor_jpeg_height = 480U, 
} sensor_jpeg_geometry_t;

typedef enum : uint16_t {
  k_sensor_reg_system_reset00 = 0x3000U, 
  k_sensor_reg_system_reset02 = 0x3002U, 
  k_sensor_reg_clock_enable02 = 0x3006U, 
  k_sensor_reg_system_ctrl0   = 0x3008U, 
  k_sensor_reg_pll_ctrl0      = 0x3034U, 
  k_sensor_reg_pll_ctrl1      = 0x3035U, 
  k_sensor_reg_pll_ctrl2      = 0x3036U, 
  k_sensor_reg_pll_ctrl3      = 0x3037U, 
  k_sensor_reg_system_root    = 0x3103U, 
  k_sensor_reg_clock_root     = 0x3108U, 
  k_sensor_reg_pclk_divider   = 0x3824U, 
} sensor_diagnostic_register_t;
 
typedef enum : uint8_t {
  k_jpeg_marker_prefix = 0xFFU, 
  k_jpeg_marker_soi    = 0xD8U, 
  k_jpeg_marker_eoi    = 0xD9U, 
} jpeg_marker_t;

typedef enum : uint8_t {
  k_sccb_op_none  = 0U, 
  k_sccb_op_read  = 1U, 
  k_sccb_op_write = 2U, 
} sccb_operation_t;
 
[[gnu::section(".sdram_data"), gnu::aligned(32)]] static uint8_t s_jpeg[k_sensor_jpeg_buffer_bytes];
static ra8_ov5640_t                                              s_sensor;
static ra8_camera_source_t                                       s_source;
static ra8_camera_source_ceu_state_t                             s_source_state;
static ra8_camera_codec_t                                        s_codec;
static ra8_ov5640_jpeg_status_t                                  s_last_jpeg_status;
static ra8_err_t                                                 s_last_jpeg_status_err;
static ra8_err_t                                                 s_last_sccb_err;
static uint16_t                                                  s_last_sccb_reg;
static sccb_operation_t                                          s_last_sccb_op;
static bool                                                      s_camera_initialized;
static bool                                                      s_sensor_bound;
static bool                                                      s_sensor_streaming;

static ra8_err_t sensor_sccb_read(void* ctx, uint8_t address, uint16_t reg, uint8_t* out_value)
{
  const ra8_err_t err = ra8_board_camera_sccb_read_reg(ctx, address, reg, out_value);
  s_last_sccb_op      = k_sccb_op_read;
  s_last_sccb_reg     = reg;
  s_last_sccb_err     = err;
  return err;
}

static ra8_err_t sensor_sccb_write(void* ctx, uint8_t address, uint16_t reg, uint8_t value)
{
  const ra8_err_t err = ra8_board_camera_sccb_write_reg(ctx, address, reg, value);
  s_last_sccb_op      = k_sccb_op_write;
  s_last_sccb_reg     = reg;
  s_last_sccb_err     = err;
  return err;
}

static ra8_err_t sensor_bind(void)
{
  const ra8_ov5640_bus_t bus = {
    .read_reg  = sensor_sccb_read,
    .write_reg = sensor_sccb_write,
    .delay_ms  = ra8_board_camera_delay_ms,
    .ctx       = nullptr,
  };
  return ra8_ov5640_init(&s_sensor, &bus);
}

static ra8_camera_source_ceu_cfg_t sensor_ceu_config(void)
{
  const ra8_ceu_config_t ceu = {
    .width_px        = (uint16_t)k_sensor_jpeg_width,
    .height_px       = (uint16_t)k_sensor_jpeg_height,
    .x_capture_px    = (uint16_t)k_sensor_jpeg_width,
    .y_capture_lines = (uint16_t)k_sensor_jpeg_height,
    .bytes_per_pixel = 1U,
    .dst_stride      = (uint16_t)k_sensor_jpeg_width,
    .capture_format  = k_ra8_ceu_fmt_data_enable,
    .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,
    .byte_swap       = {.swap_8_bit = true, .swap_16_bit = true, .swap_32_bit = true},
    .burst_mode      = k_ra8_ceu_burst_256,
    .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},
    .image_area_size = (uint32_t)k_sensor_jpeg_buffer_bytes,
  };
  return (ra8_camera_source_ceu_cfg_t){
    .ceu = ceu,
    .output =
      {
        .frame_bytes_max = (uint32_t)k_sensor_jpeg_buffer_bytes,
        .stride_bytes    = 0U,
        .width           = (uint16_t)k_sensor_jpeg_width,
        .height          = (uint16_t)k_sensor_jpeg_height,
        .format          = k_ra8_camera_format_jpeg,
      },
    .poll_interval_ms = (uint32_t)k_sensor_jpeg_poll_ms,
    .poll_attempts    = (uint32_t)k_sensor_jpeg_poll_tries,
  };
}

RA8_INTERNAL static void internal_reset_camera_diagnostics(void)
{
  s_camera_initialized = false;
  s_sensor_bound       = false;
  s_last_sccb_op       = k_sccb_op_none;
  s_last_sccb_reg      = 0U;
  s_last_sccb_err      = k_ra8_ok;
  s_sensor_streaming   = false;
}

RA8_INTERNAL static ra8_err_t internal_bring_up_sensor(void)
{
  ra8_err_t err = ra8_board_camera_xclk_start((uint32_t)k_sensor_jpeg_xclk_hz);
  if (err == k_ra8_ok) {
    err = ra8_board_camera_select_parallel();
  }
  if (err == k_ra8_ok) {
    ra8_delay_ms((uint32_t)k_sensor_jpeg_settle_ms);
    err = ra8_board_camera_reset();
  }
  if (err == k_ra8_ok) {
    err = sensor_bind();
    if (err == k_ra8_ok) {
      s_sensor_bound = true;
    }
  }
  uint16_t chip_id = 0U;
  if (err == k_ra8_ok) {
    err = ra8_ov5640_probe(&s_sensor, &chip_id);
  }
  if ((err == k_ra8_ok) && (chip_id != (uint16_t)k_ra8_ov5640_chip_id)) {
    err = k_ra8_err_hw_init_failed;
  }
  if (err == k_ra8_ok) {
    err                = ra8_ov5640_configure(&s_sensor, k_ra8_ov5640_mode_vga_jpeg);
    s_sensor_streaming = (err == k_ra8_ok);
  }
  return err;
}

RA8_INTERNAL static ra8_err_t internal_bring_up_capture_pipeline(void)
{
  ra8_err_t err = ra8_board_camera_route_parallel_pins();
  if (err == k_ra8_ok) {
    const ra8_camera_source_ceu_cfg_t cfg = sensor_ceu_config();
    err = ra8_camera_source_ceu_init(&s_source, &s_source_state, &cfg);
  }
  if (err == k_ra8_ok) {
    err = ra8_camera_codec_passthrough_init(&s_codec);
  }
  return err;
}
 
ra8_err_t c6_cam_camera_init(void)
{
  internal_reset_camera_diagnostics();
  ra8_err_t err = internal_bring_up_sensor();
  if (err == k_ra8_ok) {
    err = internal_bring_up_capture_pipeline();
  }
  s_camera_initialized = (err == k_ra8_ok);
  return err;
}

static uint32_t jpeg_trim_to_eoi(const uint8_t* jpeg, uint32_t bytes)
{
  if ((bytes < 4U) || (jpeg[0] != (uint8_t)k_jpeg_marker_prefix) ||
      (jpeg[1] != (uint8_t)k_jpeg_marker_soi)) {
    return 0U;
  }
  for (uint32_t i = 1U; i < bytes; i += 1U) {
    if ((jpeg[i - 1U] == (uint8_t)k_jpeg_marker_prefix) &&
        (jpeg[i] == (uint8_t)k_jpeg_marker_eoi)) {
      return i + 1U;
    }
  }
  return 0U;
}
 
ra8_err_t c6_cam_camera_capture_jpeg(const uint8_t**        out_jpeg,
                                     uint32_t*              out_bytes,
                                     c6_cam_frame_timing_t* out_timing)
{
  if ((out_jpeg == nullptr) || (out_bytes == nullptr) || (out_timing == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *out_jpeg                        = nullptr;
  *out_bytes                       = 0U;
  *out_timing                      = (c6_cam_frame_timing_t){};
  const uint32_t start             = ra8_time_ms();
  out_timing->timestamp_ms         = start;
  const ra8_camera_buffer_t buffer = {
    .data     = s_jpeg,
    .capacity = (uint32_t)sizeof(s_jpeg),
  };
  ra8_err_t stream_err = k_ra8_ok;
  if (!s_sensor_streaming) {
    stream_err         = ra8_ov5640_stream_set(&s_sensor, true);
    s_sensor_streaming = (stream_err == k_ra8_ok);
  }
  if (stream_err != k_ra8_ok) {
    return stream_err;
  }
  ra8_camera_frame_t frame = {};
  const ra8_err_t    err   = ra8_camera_source_capture(&s_source, &buffer, &frame);
  out_timing->capture_ms   = ra8_time_ms() - start;
  s_last_jpeg_status_err   = ra8_ov5640_jpeg_status_get(&s_sensor, &s_last_jpeg_status);
  if (err != k_ra8_ok) {
    return err;
  }
  const uint32_t jpeg_bytes = jpeg_trim_to_eoi(frame.data, frame.bytes);
  if (jpeg_bytes == 0U) {
    return k_ra8_err_invalid_size;
  }
  frame.bytes                         = jpeg_bytes;
  const ra8_camera_buffer_t no_output = {};
  ra8_camera_frame_t        jpeg      = {};
  const ra8_err_t codec_err = ra8_camera_codec_encode(&s_codec, &frame, &no_output, &jpeg);
  if (codec_err != k_ra8_ok) {
    return codec_err;
  }
  *out_jpeg  = jpeg.data;
  *out_bytes = jpeg.bytes;
  return k_ra8_ok;
}
 
const char* c6_cam_camera_description(void)
{
  return "frame=640x480 sensor-JPEG CEU data-enable backend";
}

static void sensor_report_register(const char* label, uint16_t reg)
{
  uint8_t         value = 0U;
  const ra8_err_t err   = ra8_ov5640_read_reg(&s_sensor, reg, &value);
  c6_cam_puts(label);
  if (err == k_ra8_ok) {
    c6_cam_put_u32(value);
  } else {
    c6_cam_puts(ra8_err_to_str(err));
  }
}

RA8_INTERNAL static void internal_report_sccb_state(void)
{
  c6_cam_puts(" sccb_op=");
  if (s_last_sccb_op == k_sccb_op_read) {
    c6_cam_puts("read");
  } else if (s_last_sccb_op == k_sccb_op_write) {
    c6_cam_puts("write");
  } else {
    c6_cam_puts("none");
  }
  c6_cam_puts(" sccb_reg=");
  c6_cam_put_u32(s_last_sccb_reg);
  c6_cam_puts(" sccb_err=");
  c6_cam_puts(ra8_err_to_str(s_last_sccb_err));
}

RA8_INTERNAL static void internal_report_sensor_registers(void)
{
  if (!s_sensor_bound) {
    return;
  }
  sensor_report_register(" r3000=", (uint16_t)k_sensor_reg_system_reset00);
  sensor_report_register(" r3002=", (uint16_t)k_sensor_reg_system_reset02);
  sensor_report_register(" r3006=", (uint16_t)k_sensor_reg_clock_enable02);
  sensor_report_register(" r3008=", (uint16_t)k_sensor_reg_system_ctrl0);
  sensor_report_register(" r3034=", (uint16_t)k_sensor_reg_pll_ctrl0);
  sensor_report_register(" r3035=", (uint16_t)k_sensor_reg_pll_ctrl1);
  sensor_report_register(" r3036=", (uint16_t)k_sensor_reg_pll_ctrl2);
  sensor_report_register(" r3037=", (uint16_t)k_sensor_reg_pll_ctrl3);
  sensor_report_register(" r3103=", (uint16_t)k_sensor_reg_system_root);
  sensor_report_register(" r3108=", (uint16_t)k_sensor_reg_clock_root);
  sensor_report_register(" r3824=", (uint16_t)k_sensor_reg_pclk_divider);
}

RA8_INTERNAL static void internal_report_capture_events(void)
{
  uint32_t events = 0U;
  if (ra8_camera_source_ceu_get_last_events(&s_source_state, &events) == k_ra8_ok) {
    c6_cam_puts(" ceu_events=");
    c6_cam_put_u32(events);
  }
}

RA8_INTERNAL static void internal_report_jpeg_status_detail(void)
{
  if (s_last_jpeg_status_err != k_ra8_ok) {
    return;
  }
  c6_cam_puts(" sensor_jpeg_bytes=");
  c6_cam_put_u32(s_last_jpeg_status.encoded_bytes);
  c6_cam_puts(" overflow=");
  c6_cam_put_u32(s_last_jpeg_status.fifo_overflow ? 1U : 0U);
  c6_cam_puts(" yuv422=");
  c6_cam_put_u32(s_last_jpeg_status.input_is_yuv422 ? 1U : 0U);
  c6_cam_puts(" header=");
  c6_cam_put_u32(s_last_jpeg_status.header_output ? 1U : 0U);
  c6_cam_puts(" jpeg_enabled=");
  c6_cam_put_u32(s_last_jpeg_status.compression_enabled ? 1U : 0U);
  c6_cam_puts(" width=");
  c6_cam_put_u32(s_last_jpeg_status.compression_width);
  c6_cam_puts(" height=");
  c6_cam_put_u32(s_last_jpeg_status.compression_height);
  c6_cam_puts(" ctrl01=");
  c6_cam_put_u32(s_last_jpeg_status.jpeg_ctrl01);
  c6_cam_puts(" vfifo00=");
  c6_cam_put_u32(s_last_jpeg_status.vfifo_ctrl00);
  c6_cam_puts(" href_min=");
  c6_cam_put_u32(s_last_jpeg_status.href_minimum_blanking);
}
 
void c6_cam_camera_report_last_error(void)
{
  internal_report_sccb_state();
  internal_report_sensor_registers();
  if (!s_camera_initialized) {
    return;
  }
  internal_report_capture_events();
  c6_cam_puts(" sensor_status=");
  c6_cam_puts(ra8_err_to_str(s_last_jpeg_status_err));
  internal_report_jpeg_status_detail();
}