main.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_check.h"
#include "ra8_dotf.h"
#include "ra8_err.h"
#include "ra8_isr.h"
#include "ra8_mstp.h"
#include "ra8_time.h"

static const char* s_tag = "dotf_demo";

typedef enum : uint32_t {
  k_dotf_demo_baud      = 115200U, 
  k_dotf_demo_period_ms = 1000U,   
} dotf_demo_config_t;

typedef enum : uint8_t {
  k_dotf_demo_ch0 = 0U, 
  k_dotf_demo_ch1 = 1U, 
} dotf_demo_chan_t;

typedef enum : uint32_t {
  k_dotf_demo_err_unset = 0xFFFFFFFFU, 
} dotf_demo_sentinel_t;

static const uint8_t s_dotf_demo_ok_msg[]  = "dotf: ch0/1 init=ok selftest=run ok=Y\r\n";
static const uint8_t s_dotf_demo_bad_msg[] = "dotf: selftest=FAIL ok=N\r\n";

volatile uint32_t g_dotf_ok = 0U;

volatile uint32_t g_dotf_init_err = (uint32_t)k_dotf_demo_err_unset;

volatile uint32_t g_dotf_reg00 = 0U;

volatile uint32_t g_dotf_st0_snap = 0U;

volatile uint32_t g_dotf_st1_snap = 0U;

volatile uint32_t g_dotf_heartbeat = 0U;

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

RA8_INTERNAL static void internal_dotf_demo_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
 
  if (ra8_cgc_init() != k_ra8_ok) {
    internal_dotf_demo_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    internal_dotf_demo_panic_halt();
  }
  if (ra8_mstp_init() != k_ra8_ok) {
    internal_dotf_demo_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    internal_dotf_demo_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_dotf_demo_baud) != k_ra8_ok) {
    internal_dotf_demo_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    internal_dotf_demo_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led2) != k_ra8_ok) {
    internal_dotf_demo_panic_halt();
  }
}

[[nodiscard]] RA8_INTERNAL static uint8_t
internal_dotf_demo_verdict(ra8_err_t st0_err, ra8_err_t st1_err, ra8_err_t status_err)
{
  const bool ok = (st0_err == k_ra8_ok) && (st1_err == k_ra8_ok) && (status_err == k_ra8_ok);
  return ok ? 1U : 0U;
}

[[nodiscard]] RA8_INTERNAL static ra8_err_t internal_dotf_demo_sample(uint8_t* out_ok)
{
  RA8_CHECK_NULL_PTR(out_ok, s_tag, "out_ok must not be nullptr");
 
  uint32_t        st0     = 0U;
  const ra8_err_t st0_err = ra8_dotf_run_self_test((uint8_t)k_dotf_demo_ch0, &st0);
  g_dotf_st0_snap         = st0;
 
  uint32_t        st1     = 0U;
  const ra8_err_t st1_err = ra8_dotf_run_self_test((uint8_t)k_dotf_demo_ch1, &st1);
  g_dotf_st1_snap         = st1;
 
  uint32_t        reg00    = 0U;
  const ra8_err_t stat_err = ra8_dotf_get_status((uint8_t)k_dotf_demo_ch0, &reg00);
  g_dotf_reg00             = reg00;
 
  *out_ok = internal_dotf_demo_verdict(st0_err, st1_err, stat_err);
  if (st0_err != k_ra8_ok) {
    return st0_err;
  }
  if (st1_err != k_ra8_ok) {
    return st1_err;
  }
  return stat_err;
}
 
void main(void)
{
  internal_dotf_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 maskable NVIC
   * source is armed; DOTF raises no IRQ of its own. */
  ra8_isr_globals_enable();
 
  const ra8_err_t init_err = ra8_dotf_init();
  g_dotf_init_err          = (uint32_t)init_err;
  if (init_err != k_ra8_ok) {
    internal_dotf_demo_panic_halt();
  }
 
  while (1) {
    uint8_t         ok   = 0U;
    const ra8_err_t err  = internal_dotf_demo_sample(&ok);
    const uint8_t   good = (err == k_ra8_ok && ok != 0U) ? 1U : 0U;
    g_dotf_ok            = (uint32_t)good;
    if (good != 0U) {
      (void)ra8_board_uart_console_write(s_dotf_demo_ok_msg,
                                         (size_t)(sizeof(s_dotf_demo_ok_msg) - 1U));
      (void)ra8_board_led_toggle(k_ra8_board_led1);
    } else {
      (void)ra8_board_uart_console_write(s_dotf_demo_bad_msg,
                                         (size_t)(sizeof(s_dotf_demo_bad_msg) - 1U));
      (void)ra8_board_led_toggle(k_ra8_board_led2);
    }
    ++g_dotf_heartbeat;
    ra8_delay_ms(k_dotf_demo_period_ms);
  }
  internal_dotf_demo_panic_halt();
}