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

typedef enum : uint32_t {
  k_ms_per_sec = 1000U, 
} wdt_demo_time_unit_t;
 
typedef enum : uint32_t {
  k_wdt_demo_baud          = 115200U, 
  k_wdt_demo_refresh_ms    = 100U,    
  k_wdt_demo_alive_seconds = 30U,     
} wdt_demo_const_t;

static const uint8_t s_wdt_demo_msg_pwr[] = "wdt: boot reason=power_on\r\n";
static const uint8_t s_wdt_demo_msg_wdt[] = "wdt: boot reason=iwdt\r\n";
static const uint8_t s_wdt_demo_msg_other[] = "wdt: boot reason=other\r\n";
static const uint8_t s_wdt_demo_msg_stop[] = "wdt: stopping refresh, expect reset\r\n";

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

RA8_INTERNAL static const uint8_t* internal_wdt_demo_banner_for(ra8_reset_cause_t cause,
                                                                uint32_t*         out_len)
{
  if (cause == k_ra8_reset_cause_power_on) {
    *out_len = (uint32_t)(sizeof(s_wdt_demo_msg_pwr) - 1U);
    return s_wdt_demo_msg_pwr;
  }
  if (cause == k_ra8_reset_cause_iwdt) {
    *out_len = (uint32_t)(sizeof(s_wdt_demo_msg_wdt) - 1U);
    return s_wdt_demo_msg_wdt;
  }
  *out_len = (uint32_t)(sizeof(s_wdt_demo_msg_other) - 1U);
  return s_wdt_demo_msg_other;
}

RA8_INTERNAL static void internal_wdt_demo_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    internal_wdt_demo_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    internal_wdt_demo_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    internal_wdt_demo_panic_halt();
  }
  if (ra8_reset_init() != k_ra8_ok) {
    internal_wdt_demo_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_wdt_demo_baud) != k_ra8_ok) {
    internal_wdt_demo_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    internal_wdt_demo_panic_halt();
  }
  if (ra8_iwdt_init() != k_ra8_ok) {
    internal_wdt_demo_panic_halt();
  }
}
 
void main(void)
{
  internal_wdt_demo_setup_or_halt();
  ra8_isr_globals_enable();
 
  ra8_reset_cause_t cause = k_ra8_reset_cause_unknown;
  (void)ra8_reset_get_cause(&cause);
  uint32_t       msg_len = 0U;
  const uint8_t* msg     = internal_wdt_demo_banner_for(cause, &msg_len);
  (void)ra8_board_uart_console_write(msg, (size_t)msg_len);
 
  /* Stage 1: refresh for ``alive_seconds`` seconds. */
  const uint32_t refreshes_per_sec = k_ms_per_sec / (uint32_t)k_wdt_demo_refresh_ms;
  const uint32_t total_refreshes   = (uint32_t)k_wdt_demo_alive_seconds * refreshes_per_sec;
  for (uint32_t i = 0U; i < total_refreshes; ++i) {
    ra8_iwdt_refresh_deferred();
    (void)ra8_board_led_toggle(k_ra8_board_led1);
    ra8_delay_ms((uint32_t)k_wdt_demo_refresh_ms);
  }
 
  /* Stage 2: stop refreshing and let the IWDT underflow reset us. */
  (void)ra8_board_uart_console_write(s_wdt_demo_msg_stop,
                                     (size_t)(sizeof(s_wdt_demo_msg_stop) - 1U));
  while (1) {
    __asm__ volatile("wfi");
  }
}