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: alarm fired\r\n";
static const uint8_t s_rtc_demo_boot_msg[] = "rtc: 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();
  }
  /* Enable global interrupts before the RTC count-source bring-up: that
   * step blocks on ra8_delay_ms for the sub-clock stabilization time, and
   * with IRQs unmasked ra8_delay_ms advances off the SysTick tick counter
   * (the demo registers no RTC NVIC handler -- it polls the status flag). */
  ra8_isr_globals_enable();
  /* Bring up and select the RTC count source BEFORE ra8_rtc_init(), or the
   * counter never advances and the +5 s alarm never fires. Primary source is
   * the EK-RA8D2 32.768 kHz sub-clock crystal (accurate). On a board without
   * the crystal, swap the argument to k_ra8_rtc_clk_loco (internal LOCO,
   * crystal-free) and re-flash. */
  if (ra8_rtc_clock_init(k_ra8_rtc_clk_subclock) != 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;
  }
  return ra8_rtc_set_irq_enable((uint8_t)k_ra8_rtc_irq_alarm);
}
 
void main(void)
{
  internal_rtc_demo_setup_or_halt();
 
  /* 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.
   * (Global IRQs were already enabled in internal_rtc_demo_setup_or_halt.) */
  (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 the alarm flag -- on real silicon RCR1.AIE drives an NVIC
     * line, but for this demo we just spin against the status bit. */
    uint8_t status = 0U;
    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 & (uint8_t)k_ra8_rtc_irq_alarm) == 0U);
 
    if (ra8_board_uart_console_write(s_rtc_demo_log_msg,
                                     (size_t)(sizeof(s_rtc_demo_log_msg) - 1U)) != k_ra8_ok) {
      break;
    }
    if (ra8_rtc_clear_status((uint8_t)k_ra8_rtc_irq_alarm) != 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();
}