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_err.h"
#include "ra8_isr.h"
#include "ra8_time.h"
#include "ra8_wdt.h"

typedef enum : uint32_t {
  k_wdt_window_demo_baud    = 115200U, 
  k_wdt_window_demo_poll_ms = 5U,      
} wdt_window_demo_const_t;

typedef enum : uint16_t {
  k_wdt_window_demo_window_low  = 256U, 
  k_wdt_window_demo_window_high = 768U, 
} wdt_window_demo_window_t;
 
static const uint8_t k_wdt_window_demo_msg_refresh[] = "wdt: window_tick=ok\r\n";
static const uint8_t k_wdt_window_demo_msg_boot[]    = "wdt: window-mode boot\r\n";
 
static void wdt_window_demo_panic_halt(void)
{
  while (1) {
    __asm__ volatile("wfi");
  }
}
 
static void wdt_window_demo_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    wdt_window_demo_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    wdt_window_demo_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    wdt_window_demo_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_wdt_window_demo_baud) != k_ra8_ok) {
    wdt_window_demo_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    wdt_window_demo_panic_halt();
  }
}

static bool wdt_window_demo_in_window(uint16_t counter)
{
  return (counter >= (uint16_t)k_wdt_window_demo_window_low) &&
         (counter <= (uint16_t)k_wdt_window_demo_window_high);
}

static void wdt_window_demo_banner(const uint8_t* msg, uint32_t len)
{
  (void)ra8_board_uart_console_write(msg, (size_t)len);
}
 
static const uint8_t k_wdt_window_demo_msg_init_failed[]    = "wdt: init failed\r\n";
static const uint8_t k_wdt_window_demo_msg_counter_failed[] = "wdt: get_counter failed\r\n";
static const uint8_t k_wdt_window_demo_msg_refresh_failed[] = "wdt: refresh_for failed\r\n";
static const uint8_t k_wdt_window_demo_msg_clear_failed[]   = "wdt: clear_status failed\r\n";

static bool wdt_window_demo_iter(void)
{
  uint16_t counter = 0U;
  if (ra8_wdt_get_counter(&counter) != k_ra8_ok) {
    wdt_window_demo_banner(k_wdt_window_demo_msg_counter_failed,
                           (uint32_t)(sizeof(k_wdt_window_demo_msg_counter_failed) - 1U));
    return false;
  }
  if (!wdt_window_demo_in_window(counter)) {
    return true;
  }
  if (ra8_wdt_refresh_for(k_ra8_wdt0) != k_ra8_ok) {
    wdt_window_demo_banner(k_wdt_window_demo_msg_refresh_failed,
                           (uint32_t)(sizeof(k_wdt_window_demo_msg_refresh_failed) - 1U));
    return false;
  }
  if (ra8_wdt_clear_status() != k_ra8_ok) {
    wdt_window_demo_banner(k_wdt_window_demo_msg_clear_failed,
                           (uint32_t)(sizeof(k_wdt_window_demo_msg_clear_failed) - 1U));
    return false;
  }
  (void)ra8_board_led_toggle(k_ra8_board_led1);
  wdt_window_demo_banner(k_wdt_window_demo_msg_refresh,
                         (uint32_t)(sizeof(k_wdt_window_demo_msg_refresh) - 1U));
  return true;
}
 
void main(void)
{
  wdt_window_demo_setup_or_halt();
  ra8_isr_globals_enable();
 
  /* Boot banner -- emit before ra8_wdt_init so the HIL host can see
   * the firmware booted even if the WDT bring-up fails. */
  (void)ra8_board_uart_console_write(k_wdt_window_demo_msg_boot,
                                     (size_t)(sizeof(k_wdt_window_demo_msg_boot) - 1U));
 
  /* on_expiry=k_ra8_wdt_on_expiry_nmi (RSTIRQS=0) routes a window
   * violation through NMI/IRQ instead of a silent reset, so a bug
   * in the demo's window math shows up as a banner-loss rather than
   * a reset-loop that confuses HIL bench parsing. */
  const ra8_wdt_cfg_t cfg = {
    .timeout       = k_ra8_wdt_timeout_1024,
    .clock_div     = k_ra8_wdt_clkdiv_4,
    .window_start  = k_ra8_wdt_window_start_75,
    .window_end    = k_ra8_wdt_window_end_25,
    .on_expiry     = k_ra8_wdt_on_expiry_nmi,
    .stop_in_sleep = k_ra8_wdt_sleep_stop_count,
  };
  if (ra8_wdt_init(&cfg) != k_ra8_ok) {
    wdt_window_demo_banner(k_wdt_window_demo_msg_init_failed,
                           (uint32_t)(sizeof(k_wdt_window_demo_msg_init_failed) - 1U));
    wdt_window_demo_panic_halt();
  }
 
  while (wdt_window_demo_iter()) {
    ra8_delay_ms((uint32_t)k_wdt_window_demo_poll_ms);
  }
  wdt_window_demo_panic_halt();
}