main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_elc_regs.h"
#include "ra8_err.h"
#include "ra8_isr.h"
#include "ra8_lpm.h"
#include "ra8_lpm_regs.h"
#include "ra8_time.h"
#include "ra8_ulpt.h"
#include "ra8_ulpt_regs.h"

typedef enum : uint32_t {
  k_lpi_baud = 115200U, 
  /* ULPTLCLK = LOCO / 1 = 32.768 kHz; 0x4000 (16384) ticks ~= 0.5 s. A
   * sub-second period keeps the bench heartbeat prompt without spinning
   * the console. */
  k_lpi_period_ticks = 0x4000U, 
  /* Bounded spin (NASA P10 Rule 2) waiting for ULPTCR.TCSTF to confirm
   * the count actually started before we drop into standby. */
  k_lpi_tcstf_poll_limit = 0x100000U, 
  /* Number of wake-work-standby periods before the app reports PASS and
   * parks. Bounds the outer loop (NASA P10 Rule 2). */
  k_lpi_period_count = 8U, 
} lpi_const_t;

typedef enum : uint8_t {
  k_lpi_channel = 0U, 
} lpi_chan_t;

typedef enum : uint8_t {
  k_lpi_led = (uint8_t)k_ra8_board_led1, 
} lpi_led_t;

static const uint8_t k_lpi_boot_msg[] = "lpm_periodic_idle: boot\r\n";

static const uint8_t k_lpi_work_msg[] = "lpm_periodic_idle: work\r\n";

static const uint8_t k_lpi_pass_msg[] = "lpm_periodic_idle PASS\r\n";

volatile uint32_t g_lpm_periodic_wake_count = 0U;

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

static void lpi_ulpt_isr(void* ctx)
{
  (void)ctx;
  g_lpm_periodic_wake_count++;
}

[[nodiscard]] static ra8_err_t lpi_wait_count_started(uint8_t channel)
{
  const uint8_t tcstf_mask = (uint8_t)(1U << (uint8_t)k_ra8_ulpt_bit_tcstf);
  for (uint32_t i = 0U; i < (uint32_t)k_lpi_tcstf_poll_limit; ++i) {
    uint8_t   status = 0U;
    ra8_err_t err    = ra8_ulpt_get_status(channel, &status);
    if (err != k_ra8_ok) {
      return err;
    }
    if ((status & tcstf_mask) != 0U) {
      return k_ra8_ok;
    }
  }
  return k_ra8_err_hw_timeout;
}

static void lpi_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    lpi_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    lpi_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    lpi_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_lpi_baud) != k_ra8_ok) {
    lpi_panic_halt();
  }
  if (ra8_board_led_init((ra8_board_led_id_t)k_lpi_led) != k_ra8_ok) {
    lpi_panic_halt();
  }
  if (ra8_ulpt_init() != k_ra8_ok) {
    lpi_panic_halt();
  }
  const ra8_lpm_config_t lpm_cfg = {
    .io_port_keep     = false,
    .opa_bus_keep     = true,
    .sscr_fast_return = false,
    .dcdc_softstart   = k_ra8_lpm_dcssmode_128us,
    .sscr_low_power   = k_ra8_lpm_ss2lp_default,
  };
  if (ra8_lpm_init(&lpm_cfg) != k_ra8_ok) {
    lpi_panic_halt();
  }
  /* Keep LOCO running (LCSTP = 0) so ULPTLCLK survives Software Standby:
   * HUM Table 11.3 footnote *2 (p 433). */
  if (ra8_lpm_set_clock_stop(k_ra8_lpm_clock_loco, false) != k_ra8_ok) {
    lpi_panic_halt();
  }
}

[[nodiscard]] static ra8_err_t lpi_arm_wake(void)
{
  ra8_err_t err = ra8_isr_init();
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_isr_register(k_ra8_elc_event_ulpt0_ulpti,
                         lpi_ulpt_isr,
                         nullptr,
                         (uint8_t)k_ra8_isr_prio_default,
                         nullptr);
  if (err != k_ra8_ok) {
    return err;
  }
  return ra8_lpm_arm_wupen1_bits((uint32_t)k_ra8_lpm_wupen1_ulpt0u);
}

[[nodiscard]] static ra8_err_t lpi_do_work(void)
{
  ra8_err_t err = ra8_board_led_toggle((ra8_board_led_id_t)k_lpi_led);
  if (err != k_ra8_ok) {
    return err;
  }
  return ra8_board_uart_console_write(k_lpi_work_msg, (size_t)(sizeof(k_lpi_work_msg) - 1U));
}

[[nodiscard]] static ra8_err_t lpi_idle_one_period(void)
{
  ra8_err_t err = ra8_ulpt_start((uint8_t)k_lpi_channel, (uint32_t)k_lpi_period_ticks);
  if (err != k_ra8_ok) {
    return err;
  }
  err = lpi_wait_count_started((uint8_t)k_lpi_channel);
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_lpm_enter_sleep(k_ra8_sleep_mode_software_std);
  if (err != k_ra8_ok) {
    return err;
  }
  return ra8_ulpt_stop((uint8_t)k_lpi_channel);
}
 
void main(void)
{
  lpi_setup_or_halt();
 
  if (lpi_arm_wake() != k_ra8_ok) {
    lpi_panic_halt();
  }
  ra8_isr_globals_enable();
 
  if (ra8_board_uart_console_write(k_lpi_boot_msg, (size_t)(sizeof(k_lpi_boot_msg) - 1U)) !=
      k_ra8_ok) {
    lpi_panic_halt();
  }
 
  /* Bounded periodic loop (NASA P10 Rule 2): k_lpi_period_count periods
   * of work-then-standby, each woken by the ULPT0 underflow. */
  for (uint32_t period = 0U; period < (uint32_t)k_lpi_period_count; ++period) {
    if (lpi_do_work() != k_ra8_ok) {
      lpi_panic_halt();
    }
    if (lpi_idle_one_period() != k_ra8_ok) {
      lpi_panic_halt();
    }
  }
 
  if (ra8_board_uart_console_write(k_lpi_pass_msg, (size_t)(sizeof(k_lpi_pass_msg) - 1U)) !=
      k_ra8_ok) {
    lpi_panic_halt();
  }
 
  lpi_panic_halt();
}