main.c

Go to the documentation of this file.

 
#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_demo";

typedef enum : uint32_t {
  k_drw_demo_baud        = 115200U,     
  k_drw_demo_period_ms   = 1000U,       
  k_drw_demo_fill_argb   = 0xFF00FF00U, 
  k_drw_demo_idle_budget = 200000U,     
} drw_demo_config_t;

typedef enum : uint16_t {
  k_drw_demo_fb_dim  = 32U, 
  k_drw_demo_rect_xy = 8U,  
  k_drw_demo_rect_wh = 16U, 
  k_drw_demo_center  = 16U, 
} drw_demo_geom_t;

static const uint8_t k_drw_demo_ok_msg[]  = "drw: fill match=Y\r\n";
static const uint8_t k_drw_demo_bad_msg[] = "drw: fill match=N\r\n";

[[gnu::aligned(
  4)]] static uint32_t g_drw_fb[(uint32_t)k_drw_demo_fb_dim * (uint32_t)k_drw_demo_fb_dim];

volatile uint32_t g_drw_match = 0U;

volatile uint32_t g_drw_rev = 0U;

volatile uint32_t g_drw_fill_err = 0U;

volatile uint32_t g_drw_heartbeat = 0U;

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

static uint32_t drw_demo_px(uint16_t x, uint16_t y)
{
  return ((uint32_t)y * (uint32_t)k_drw_demo_fb_dim) + (uint32_t)x;
}

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

[[nodiscard]] static ra8_err_t drw_demo_configure(void)
{
  const ra8_drw_config_t cfg = {
    .framebuffer_addr       = (uintptr_t)g_drw_fb,
    .pitch_px               = (uint16_t)k_drw_demo_fb_dim,
    .format                 = k_ra8_drw_writefmt_argb8888,
    .enable_caches          = false,
    .enable_buffered_writes = false,
  };
  uint32_t rev = 0U;
  if (ra8_drw_get_hwrevision(&rev) == k_ra8_ok) {
    g_drw_rev = rev;
  }
  return ra8_drw_init(&cfg);
}

[[nodiscard]] static ra8_err_t drw_demo_fill_and_check(uint8_t* out_ok)
{
  RA8_CHECK_NULL_PTR(out_ok, s_tag, "out_ok must not be nullptr");
 
  for (uint32_t i = 0U; i < (uint32_t)k_drw_demo_fb_dim * (uint32_t)k_drw_demo_fb_dim; ++i) {
    g_drw_fb[i] = 0U;
  }
 
  const ra8_drw_rect_t rect = {
    .x              = (int16_t)k_drw_demo_rect_xy,
    .y              = (int16_t)k_drw_demo_rect_xy,
    .width_px       = (uint16_t)k_drw_demo_rect_wh,
    .height_px      = (uint16_t)k_drw_demo_rect_wh,
    .color_argb8888 = (uint32_t)k_drw_demo_fill_argb,
  };
  const ra8_err_t ferr = ra8_drw_fill_rect(&rect);
  if (ferr != k_ra8_ok) {
    g_drw_fill_err = (uint32_t)ferr;
    return ferr;
  }
  const ra8_err_t werr = ra8_drw_wait_idle((uint32_t)k_drw_demo_idle_budget);
  g_drw_fill_err       = (werr == k_ra8_ok) ? 0U : (uint32_t)werr;
 
  const uint32_t centre = g_drw_fb[drw_demo_px(k_drw_demo_center, k_drw_demo_center)];
  const uint32_t tl     = g_drw_fb[drw_demo_px(0U, 0U)];
  const uint32_t br =
    g_drw_fb[drw_demo_px((uint16_t)(k_drw_demo_fb_dim - 1U), (uint16_t)(k_drw_demo_fb_dim - 1U))];
  *out_ok = (centre == (uint32_t)k_drw_demo_fill_argb && tl == 0U && br == 0U) ? 1U : 0U;
  return k_ra8_ok;
}
 
void main(void)
{
  drw_demo_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_demo_configure() != k_ra8_ok) {
    drw_demo_panic_halt();
  }
 
  while (1) {
    uint8_t         ok   = 0U;
    const ra8_err_t err  = drw_demo_fill_and_check(&ok);
    const uint8_t   good = (err == k_ra8_ok && ok != 0U) ? 1U : 0U;
    g_drw_match          = (uint32_t)good;
    if (good != 0U) {
      (void)ra8_board_uart_console_write(k_drw_demo_ok_msg,
                                         (size_t)(sizeof(k_drw_demo_ok_msg) - 1U));
      (void)ra8_board_led_toggle(k_ra8_board_led1);
    } else {
      (void)ra8_board_uart_console_write(k_drw_demo_bad_msg,
                                         (size_t)(sizeof(k_drw_demo_bad_msg) - 1U));
      (void)ra8_board_led_toggle(k_ra8_board_led2);
    }
    ++g_drw_heartbeat;
    ra8_delay_ms(k_drw_demo_period_ms);
  }
  drw_demo_panic_halt();
}