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_check.h"
#include "ra8_drw.h"
#include "ra8_err.h"
#include "ra8_isr.h"
#include "ra8_mstp.h"
#include "ra8_time.h"

static const char* s_tag = "drw_blend";

typedef enum : uint32_t {
  k_drw_blend_baud        = 115200U,     
  k_drw_blend_period_ms   = 1000U,       
  k_drw_blend_idle_budget = 200000U,     
  k_drw_blend_alpha       = 0x80U,       
  k_drw_blend_fnv_offset  = 2166136261U, 
  k_drw_blend_fnv_prime   = 16777619U,   
} drw_blend_config_t;

typedef enum : uint32_t {
  k_drw_blend_byte_bits = 8U,    
  k_drw_blend_byte_mask = 0xFFU, 
  k_drw_blend_hex_digit = 8U,    
  k_drw_blend_hi_nibble = 7U,    
  k_drw_blend_nib_bits  = 4U,    
  k_drw_blend_nib_mask  = 0xFU,  
} drw_blend_hash_t;

typedef enum : uint32_t {
  k_drw_blend_bg_argb = 0xFF202060U, 
  k_drw_blend_sp_argb = 0xFF40C040U, 
  k_drw_blend_fg_argb = 0xFFE04040U, 
  k_drw_blend_fg_a80  = 0x80E04040U, 
} drw_blend_color_t;

typedef enum : uint16_t {
  k_drw_blend_fb_dim   = 32U, 
  k_drw_blend_sp_xy    = 8U,  
  k_drw_blend_sp_wh    = 16U, 
  k_drw_blend_fg_xy    = 4U,  
  k_drw_blend_fg_wh    = 16U, 
  k_drw_blend_full_org = 0U,  
} drw_blend_geom_t;

static const uint8_t k_drw_blend_pass_pfx[] = "drw: blit+blend crc=";
static const uint8_t k_drw_blend_pass_sfx[] = " PASS\r\n";
static const uint8_t k_drw_blend_fail_msg[] = "drw: blit+blend FAIL\r\n";

[[gnu::aligned(4)]] volatile uint32_t
  g_drw_blend_fb[(uint32_t)k_drw_blend_fb_dim * (uint32_t)k_drw_blend_fb_dim];

volatile uint32_t g_drw_blend_crc = 0U;

volatile uint32_t g_drw_blend_err = 0U;

volatile uint32_t g_drw_blend_heartbeat = 0U;

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

static void drw_blend_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
 
  if (ra8_cgc_init() != k_ra8_ok) {
    drw_blend_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    drw_blend_panic_halt();
  }
  if (ra8_mstp_init() != k_ra8_ok) {
    drw_blend_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    drw_blend_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_drw_blend_baud) != k_ra8_ok) {
    drw_blend_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    drw_blend_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led2) != k_ra8_ok) {
    drw_blend_panic_halt();
  }
}

[[nodiscard]] static ra8_err_t drw_blend_configure(void)
{
  const ra8_drw_config_t cfg = {
    .framebuffer_addr       = (uintptr_t)g_drw_blend_fb,
    .pitch_px               = (uint16_t)k_drw_blend_fb_dim,
    .format                 = k_ra8_drw_writefmt_argb8888,
    .enable_caches          = false,
    .enable_buffered_writes = false,
  };
  return ra8_drw_init(&cfg);
}

[[nodiscard]] static ra8_err_t
drw_blend_fill(int16_t x, int16_t y, uint16_t w, uint16_t h, uint32_t argb)
{
  const ra8_drw_rect_t rect = {
    .x              = x,
    .y              = y,
    .width_px       = w,
    .height_px      = h,
    .color_argb8888 = argb,
  };
  const ra8_err_t ferr = ra8_drw_fill_rect(&rect);
  if (ferr != k_ra8_ok) {
    return ferr;
  }
  return ra8_drw_wait_idle((uint32_t)k_drw_blend_idle_budget);
}

[[nodiscard]] static ra8_err_t drw_blend_arm(void)
{
  const ra8_drw_gradient_t grad = {
    .color1_argb8888 = (uint32_t)k_drw_blend_fg_argb,
    .color2_argb8888 = (uint32_t)k_drw_blend_bg_argb,
  };
  const ra8_err_t gerr = ra8_drw_set_gradient(&grad);
  if (gerr != k_ra8_ok) {
    return gerr;
  }
 
  /* True source-over: out = src*a + dst*(1-a). Source factor = alpha
   * (BSF=1, BSI=0); destination factor = 1-alpha (BDF=1, BDI=1). The
   * previous descriptor left dst_invert=false (dst factor = alpha, an
   * additive mix), which is not source-over. */
  const ra8_drw_blend_t blend = {
    .use_alpha_channel = true,
    .src_factor        = true,
    .dst_factor        = true,
    .src_invert        = false,
    .dst_invert        = true,
    .src_factor_alpha  = true,
    .dst_factor_alpha  = true,
    .src_invert_alpha  = false,
    .dst_invert_alpha  = true,
    .use_color2_dst    = false,
    .global_alpha      = (uint8_t)k_drw_blend_alpha,
  };
  return ra8_drw_set_blend(&blend);
}

static uint32_t drw_blend_framebuffer_hash(void)
{
  const uint32_t words = (uint32_t)k_drw_blend_fb_dim * (uint32_t)k_drw_blend_fb_dim;
  uint32_t       hsh   = (uint32_t)k_drw_blend_fnv_offset;
  for (uint32_t w = 0U; w < words; ++w) {
    const uint32_t px = g_drw_blend_fb[w];
    for (uint32_t b = 0U; b < (uint32_t)sizeof(uint32_t); ++b) {
      const uint8_t byte =
        (uint8_t)((px >> (b * (uint32_t)k_drw_blend_byte_bits)) & (uint32_t)k_drw_blend_byte_mask);
      hsh = (hsh ^ (uint32_t)byte) * (uint32_t)k_drw_blend_fnv_prime;
    }
  }
  return hsh;
}

[[nodiscard]] static ra8_err_t drw_blend_render(uint32_t* out_crc)
{
  RA8_CHECK_NULL_PTR(out_crc, s_tag, "out_crc must not be nullptr");
 
  const ra8_err_t bg = drw_blend_fill((int16_t)k_drw_blend_full_org,
                                      (int16_t)k_drw_blend_full_org,
                                      (uint16_t)k_drw_blend_fb_dim,
                                      (uint16_t)k_drw_blend_fb_dim,
                                      (uint32_t)k_drw_blend_bg_argb);
  if (bg != k_ra8_ok) {
    g_drw_blend_err = (uint32_t)bg;
    return bg;
  }
 
  const ra8_err_t sp = drw_blend_fill((int16_t)k_drw_blend_sp_xy,
                                      (int16_t)k_drw_blend_sp_xy,
                                      (uint16_t)k_drw_blend_sp_wh,
                                      (uint16_t)k_drw_blend_sp_wh,
                                      (uint32_t)k_drw_blend_sp_argb);
  if (sp != k_ra8_ok) {
    g_drw_blend_err = (uint32_t)sp;
    return sp;
  }
 
  const ra8_err_t armed = drw_blend_arm();
  if (armed != k_ra8_ok) {
    g_drw_blend_err = (uint32_t)armed;
    return armed;
  }
 
  /* The blended fill carries the global alpha IN its colour: fill_rect
   * writes the full COLOR1 register, so passing the opaque source colour
   * here would clobber the armed alpha back to 0xFF and blend nothing. */
  const ra8_err_t fg = drw_blend_fill((int16_t)k_drw_blend_fg_xy,
                                      (int16_t)k_drw_blend_fg_xy,
                                      (uint16_t)k_drw_blend_fg_wh,
                                      (uint16_t)k_drw_blend_fg_wh,
                                      (uint32_t)k_drw_blend_fg_a80);
  if (fg != k_ra8_ok) {
    g_drw_blend_err = (uint32_t)fg;
    return fg;
  }
 
  g_drw_blend_err = 0U;
  *out_crc        = drw_blend_framebuffer_hash();
  return k_ra8_ok;
}

static void drw_blend_print_hex(uint32_t value)
{
  static const uint8_t k_hex[] = "0123456789ABCDEF";
  uint8_t              out[(uint32_t)k_drw_blend_hex_digit];
  for (uint32_t i = 0U; i < (uint32_t)k_drw_blend_hex_digit; ++i) {
    const uint32_t shift = ((uint32_t)k_drw_blend_hi_nibble - i) * (uint32_t)k_drw_blend_nib_bits;
    out[i]               = k_hex[(value >> shift) & (uint32_t)k_drw_blend_nib_mask];
  }
  (void)ra8_board_uart_console_write(out, (size_t)sizeof(out));
}

static void drw_blend_print_pass(uint32_t crc)
{
  (void)ra8_board_uart_console_write(k_drw_blend_pass_pfx,
                                     (size_t)(sizeof(k_drw_blend_pass_pfx) - 1U));
  drw_blend_print_hex(crc);
  (void)ra8_board_uart_console_write(k_drw_blend_pass_sfx,
                                     (size_t)(sizeof(k_drw_blend_pass_sfx) - 1U));
}
 
void main(void)
{
  drw_blend_setup_or_halt();
  /* Clear PRIMASK so SysTick can dispatch and ra8_delay_ms() uses the
   * SysTick path (ra8_emulator does not advance DWT_CYCCNT). No NVIC sources
   * are armed by this demo. */
  ra8_isr_globals_enable();
 
  if (drw_blend_configure() != k_ra8_ok) {
    drw_blend_panic_halt();
  }
 
  while (1) {
    uint32_t        crc = 0U;
    const ra8_err_t err = drw_blend_render(&crc);
    if (err == k_ra8_ok) {
      g_drw_blend_crc = crc;
      drw_blend_print_pass(crc);
      (void)ra8_board_led_toggle(k_ra8_board_led1);
    } else {
      (void)ra8_board_uart_console_write(k_drw_blend_fail_msg,
                                         (size_t)(sizeof(k_drw_blend_fail_msg) - 1U));
      (void)ra8_board_led_toggle(k_ra8_board_led2);
    }
    ++g_drw_blend_heartbeat;
    ra8_delay_ms(k_drw_blend_period_ms);
  }
  drw_blend_panic_halt();
}