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_rtc.h"
#include "ra8_time.h"

typedef enum : uint32_t {
  k_rtc_demo_baud         = 115200U, 
  k_rtc_demo_poll_ms      = 100U,    
  k_rtc_demo_advance_secs = 10U,     
  k_rtc_demo_ms_per_sec   = 1000U,   
} rtc_demo_const_t;

typedef enum : uint8_t {
  k_rtc_demo_secs_per_min  = 60U, 
  k_rtc_demo_mins_per_hour = 60U, 
  k_rtc_demo_hours_per_day = 24U, 
} rtc_demo_calendar_t;

typedef enum : uint16_t {
  k_rtc_demo_alarm_offset_s = 5U,    
  k_rtc_demo_seed_year_lo   = 26U,   
  k_rtc_demo_year_base      = 2000U, 
  k_rtc_demo_seed_month     = 1U,    
  k_rtc_demo_seed_day       = 1U,    
} rtc_demo_seed_t;

static const uint8_t s_rtc_demo_log_msg[]  = "rtc_per: tick\r\n";
static const uint8_t s_rtc_demo_boot_msg[] = "rtc_per: boot\r\n";

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

RA8_INTERNAL static void internal_rtc_demo_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    internal_rtc_demo_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    internal_rtc_demo_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    internal_rtc_demo_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_rtc_demo_baud) != k_ra8_ok) {
    internal_rtc_demo_panic_halt();
  }
  if (ra8_rtc_init() != k_ra8_ok) {
    internal_rtc_demo_panic_halt();
  }
  const ra8_rtc_datetime_t seed = {
    .year    = (uint16_t)(k_rtc_demo_year_base + k_rtc_demo_seed_year_lo),
    .month   = (uint8_t)k_rtc_demo_seed_month,
    .day     = (uint8_t)k_rtc_demo_seed_day,
    .weekday = 0U,
    .hour    = 0U,
    .minute  = 0U,
    .second  = 0U,
  };
  if (ra8_rtc_set(&seed) != k_ra8_ok) {
    internal_rtc_demo_panic_halt();
  }
}

[[nodiscard]] RA8_INTERNAL static ra8_err_t
internal_rtc_demo_arm_alarm(const ra8_rtc_datetime_t* now)
{
  ra8_rtc_datetime_t a = *now;
  uint16_t           s = (uint16_t)a.second + (uint16_t)k_rtc_demo_alarm_offset_s;
  a.second             = (uint8_t)(s % (uint16_t)k_rtc_demo_secs_per_min);
  uint16_t add_min     = (uint16_t)(s / (uint16_t)k_rtc_demo_secs_per_min);
  uint16_t m           = (uint16_t)a.minute + add_min;
  a.minute             = (uint8_t)(m % (uint16_t)k_rtc_demo_mins_per_hour);
  uint16_t add_hr      = (uint16_t)(m / (uint16_t)k_rtc_demo_mins_per_hour);
  uint16_t h           = (uint16_t)a.hour + add_hr;
  a.hour               = (uint8_t)(h % (uint16_t)k_rtc_demo_hours_per_day);
  ra8_err_t err        = ra8_rtc_set_alarm(&a);
  if (err != k_ra8_ok) {
    return err;
  }
  /* Enable BOTH alarm and periodic IRQ flags so the demo gates on
   * whichever fires first. The periodic interval is selected by
   * RCR1.PES inside ra8_rtc_init's default config; the bench cares
   * only that ra8_rtc_get_status reports a periodic-or-alarm event. */
  return ra8_rtc_set_irq_enable(
    (uint8_t)((uint8_t)k_ra8_rtc_irq_alarm | (uint8_t)k_ra8_rtc_irq_periodic));
}
 
void main(void)
{
  internal_rtc_demo_setup_or_halt();
  ra8_isr_globals_enable();
 
  /* Boot banner -- emit before the RTC poll loop so the HIL host can
   * confirm the firmware booted even when the sub-clock crystal is not
   * running and the alarm-fired path never reaches its own write. */
  (void)ra8_board_uart_console_write(s_rtc_demo_boot_msg,
                                     (size_t)(sizeof(s_rtc_demo_boot_msg) - 1U));
 
  while (1) {
    ra8_rtc_datetime_t now = {};
    if (ra8_rtc_get(&now) != k_ra8_ok) {
      break;
    }
    if (internal_rtc_demo_arm_alarm(&now) != k_ra8_ok) {
      break;
    }
 
    /* Poll for the periodic flag (or alarm as a fallback). On real
     * silicon RCR1.PIE drives an NVIC line, but for this demo we
     * just spin against the status bit. */
    uint8_t       status   = 0U;
    const uint8_t any_mask = (uint8_t)k_ra8_rtc_irq_alarm | (uint8_t)k_ra8_rtc_irq_periodic;
    do {
      ra8_delay_ms(k_rtc_demo_poll_ms);
      if (ra8_rtc_get_status(&status) != k_ra8_ok) {
        internal_rtc_demo_panic_halt();
      }
    } while ((status & any_mask) == 0U);
 
    (void)ra8_board_uart_console_write(s_rtc_demo_log_msg,
                                       (size_t)(sizeof(s_rtc_demo_log_msg) - 1U));
    if (ra8_rtc_clear_status(
          (uint8_t)((uint8_t)k_ra8_rtc_irq_alarm | (uint8_t)k_ra8_rtc_irq_periodic)) != k_ra8_ok) {
      break;
    }
    ra8_delay_ms((uint32_t)k_rtc_demo_advance_secs * (uint32_t)k_rtc_demo_ms_per_sec);
  }
  internal_rtc_demo_panic_halt();
}