main.c

Go to the documentation of this file.

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

static const char* s_tag = "bkup_demo";

typedef enum : uint32_t {
  k_bkup_demo_baud      = 115200U,     
  k_bkup_demo_period_ms = 1000U,       
  k_bkup_demo_sentinel  = 0x600DCAFEU, 
  k_bkup_demo_pat_mult  = 0x01010101U, 
  k_bkup_demo_pat_xor   = 0xA5A5A5A5U, 
} bkup_demo_config_t;

typedef enum : uint8_t {
  k_bkup_demo_data_words   = 30U, 
  k_bkup_demo_idx_sentinel = 30U, 
  k_bkup_demo_idx_boot     = 31U, 
} bkup_demo_layout_t;

static const uint8_t s_bkup_demo_ok_msg[] = "bkup: rw=ok ";
static const uint8_t s_bkup_demo_bad_msg[] = "bkup: rw=BAD ";
static const uint8_t s_bkup_demo_surv_y[] = "survived=Y ";
static const uint8_t s_bkup_demo_surv_n[] = "survived=N ";
static const uint8_t s_bkup_demo_crlf[] = "\r\n";

volatile uint32_t g_bkup_rw_ok = 0U;

volatile uint32_t g_bkup_survived = 0U;

volatile uint32_t g_bkup_boot_count = 0U;

volatile uint32_t g_bkup_heartbeat = 0U;

[[noreturn]] RA8_INTERNAL static void internal_bkup_demo_panic_halt(void)
{
  while (1) {
    __asm__ volatile("wfi");
  }
}

RA8_INTERNAL static uint32_t internal_bkup_demo_pattern(uint8_t i)
{
  return ((uint32_t)i * (uint32_t)k_bkup_demo_pat_mult) ^ (uint32_t)k_bkup_demo_pat_xor;
}

RA8_INTERNAL static void internal_bkup_demo_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
 
  if (ra8_cgc_init() != k_ra8_ok) {
    internal_bkup_demo_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    internal_bkup_demo_panic_halt();
  }
  if (ra8_mstp_init() != k_ra8_ok) {
    internal_bkup_demo_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    internal_bkup_demo_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_bkup_demo_baud) != k_ra8_ok) {
    internal_bkup_demo_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    internal_bkup_demo_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led2) != k_ra8_ok) {
    internal_bkup_demo_panic_halt();
  }
 
  /* Bring the VBATT backup-register block up before any VBTBKRn touch. Two
   * silicon preconditions must both hold or every VBTBKRn write is dropped:
   *
   *   1. Voltage monitor 0 (LVD0) reset must be enabled -- OFS1.PVDAS = 0
   *      (HUM Ch 12.1.3 p 499: "It is necessary to enable voltage monitor 0
   *      resets to use the battery backup function"; Ch 12.3.2 p 514). This
   *      is an option byte set in CMakeLists.txt (OFS1 = 0xFFFFFFF0); without
   *      it the VBATT area stays held in VBATT_POR reset (VBPORF = 1) and the
   *      whole block -- VBTBPCR1, VBTBKRn -- rejects writes. This is the
   *      dominant #131 root cause, verified on the bench by debugger reads.
   *   2. VBTBER.VBAE must be 1 before access -- HUM Ch 12.2.6 p 504 ("You
   *      must write 1 to VBAE before accessing VBTBKR", then "wait for at
   *      least 500 ns"). VBAE resets to 1, but ra8_bkup_init writes it and
   *      performs the mandatory settle so the sequence is explicit/correct.
   *
   * On the EK-RA8D2 VBATT is tied to VCC, so the battery power-supply switch
   * stays stopped (enable_switch = false). The window stays open for the life
   * of the demo (a J-Link/SYSRESETREQ reset keeps VCC/VBATT powered, so
   * leaving VBAE = 1 does not lose data). */
  const ra8_bkup_config_t bkup_cfg = {
    .vdet_level    = k_ra8_bkup_vdet_2p80v,
    .enable_switch = false,
    .enable_backup = true,
  };
  if (ra8_bkup_init(&bkup_cfg) != k_ra8_ok) {
    internal_bkup_demo_panic_halt();
  }
}

[[nodiscard]] RA8_INTERNAL static ra8_err_t internal_bkup_demo_rw_check(uint8_t* out_ok)
{
  RA8_CHECK_NULL_PTR(out_ok, s_tag, "out_ok must not be nullptr");
 
  for (uint8_t i = 0U; i < (uint8_t)k_bkup_demo_data_words; ++i) {
    const ra8_err_t werr = ra8_bkup_write_word(i, internal_bkup_demo_pattern(i));
    if (werr != k_ra8_ok) {
      return werr;
    }
  }
  uint8_t ok = 1U;
  for (uint8_t i = 0U; i < (uint8_t)k_bkup_demo_data_words; ++i) {
    uint32_t        got  = 0U;
    const ra8_err_t rerr = ra8_bkup_read_word(i, &got);
    if (rerr != k_ra8_ok) {
      return rerr;
    }
    if (got != internal_bkup_demo_pattern(i)) {
      ok = 0U;
    }
  }
  *out_ok = ok;
  return k_ra8_ok;
}

[[nodiscard]] RA8_INTERNAL static ra8_err_t internal_bkup_demo_survival_check(void)
{
  uint32_t        sentinel = 0U;
  const ra8_err_t serr     = ra8_bkup_read_word((uint8_t)k_bkup_demo_idx_sentinel, &sentinel);
  if (serr != k_ra8_ok) {
    return serr;
  }
  uint32_t boot = 0U;
  if (sentinel == (uint32_t)k_bkup_demo_sentinel) {
    g_bkup_survived      = 1U;
    const ra8_err_t rerr = ra8_bkup_read_word((uint8_t)k_bkup_demo_idx_boot, &boot);
    if (rerr != k_ra8_ok) {
      return rerr;
    }
    boot += 1U;
  } else {
    g_bkup_survived = 0U;
    boot            = 1U;
    const ra8_err_t merr =
      ra8_bkup_write_word((uint8_t)k_bkup_demo_idx_sentinel, (uint32_t)k_bkup_demo_sentinel);
    if (merr != k_ra8_ok) {
      return merr;
    }
  }
  const ra8_err_t cerr = ra8_bkup_write_word((uint8_t)k_bkup_demo_idx_boot, boot);
  if (cerr != k_ra8_ok) {
    return cerr;
  }
  g_bkup_boot_count = boot;
  return k_ra8_ok;
}

RA8_INTERNAL static void internal_bkup_demo_report_survival(void)
{
  const uint8_t* tag = (g_bkup_survived != 0U) ? s_bkup_demo_surv_y : s_bkup_demo_surv_n;
  /* Both suffixes are the same length ("survived=Y " / "survived=N "). */
  static_assert(sizeof(s_bkup_demo_surv_y) == sizeof(s_bkup_demo_surv_n),
                "survived=Y / survived=N suffixes must be equal length");
  const uint32_t len = (uint32_t)(sizeof(s_bkup_demo_surv_y) - 1U);
  (void)ra8_board_uart_console_write(tag, (size_t)len);
}
 
void main(void)
{
  internal_bkup_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 (internal_bkup_demo_survival_check() != k_ra8_ok) {
    internal_bkup_demo_panic_halt();
  }
 
  while (1) {
    uint8_t         rw   = 0U;
    const ra8_err_t err  = internal_bkup_demo_rw_check(&rw);
    const uint8_t   good = (err == k_ra8_ok && rw != 0U) ? 1U : 0U;
    g_bkup_rw_ok         = (uint32_t)good;
 
    if (good != 0U) {
      (void)ra8_board_uart_console_write(s_bkup_demo_ok_msg,
                                         (size_t)(sizeof(s_bkup_demo_ok_msg) - 1U));
      (void)ra8_board_led_toggle(k_ra8_board_led1);
    } else {
      (void)ra8_board_uart_console_write(s_bkup_demo_bad_msg,
                                         (size_t)(sizeof(s_bkup_demo_bad_msg) - 1U));
      (void)ra8_board_led_toggle(k_ra8_board_led2);
    }
    internal_bkup_demo_report_survival();
    (void)ra8_board_uart_console_write(s_bkup_demo_crlf, (size_t)(sizeof(s_bkup_demo_crlf) - 1U));
    ++g_bkup_heartbeat;
    ra8_delay_ms(k_bkup_demo_period_ms);
  }
  internal_bkup_demo_panic_halt();
}