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_check.h"
#include "ra8_err.h"
#include "ra8_isr.h"
#include "ra8_mstp.h"
#include "ra8_pdg.h"
#include "ra8_time.h"

static const char* s_tag = "pdg_demo";

typedef enum : uint32_t {
  k_pdg_demo_baud      = 115200U, 
  k_pdg_demo_period_ms = 1000U,   
} pdg_demo_config_t;

typedef enum : uint8_t {
  k_pdg_demo_channel    = 0U,    
  k_pdg_demo_chan_mask  = 0x01U, 
  k_pdg_demo_delay_code = 0x40U, 
} pdg_demo_chan_t;

static const uint8_t s_pdg_demo_ok_msg[]  = "pdg: dll=on ch0=on delay=0x40 cfg=ok\r\n";
static const uint8_t s_pdg_demo_bad_msg[] = "pdg: cfg=BAD\r\n";

volatile uint32_t g_pdg_cfg_ok = 0U;

volatile uint32_t g_pdg_delay_readback = 0U;

volatile uint32_t g_pdg_dll = 0U;

volatile uint32_t g_pdg_heartbeat = 0U;

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

RA8_INTERNAL static void internal_pdg_demo_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
 
  if (ra8_cgc_init() != k_ra8_ok) {
    internal_pdg_demo_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    internal_pdg_demo_panic_halt();
  }
  if (ra8_mstp_init() != k_ra8_ok) {
    internal_pdg_demo_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    internal_pdg_demo_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_pdg_demo_baud) != k_ra8_ok) {
    internal_pdg_demo_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    internal_pdg_demo_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led2) != k_ra8_ok) {
    internal_pdg_demo_panic_halt();
  }
}

[[nodiscard]] RA8_INTERNAL static ra8_err_t internal_pdg_demo_configure(void)
{
  const ra8_pdg_config_t cfg = {
    .frange       = k_ra8_pdg_frange_80_160_mhz,
    .channel_mask = (uint8_t)k_pdg_demo_chan_mask,
    .auto_tune    = 0U,
    .gptclk_hz    = 0U,
  };
  const ra8_err_t ierr = ra8_pdg_init(&cfg);
  if (ierr != k_ra8_ok) {
    return ierr;
  }
  return ra8_pdg_set_delay((uint8_t)k_pdg_demo_channel,
                           k_ra8_pdg_pin_a,
                           k_ra8_pdg_edge_rising,
                           (uint8_t)k_pdg_demo_delay_code);
}

[[nodiscard]] RA8_INTERNAL static ra8_err_t internal_pdg_demo_sample(uint8_t* out_ok)
{
  RA8_CHECK_NULL_PTR(out_ok, s_tag, "out_ok must not be nullptr");
 
  uint8_t         code = 0U;
  const ra8_err_t derr =
    ra8_pdg_get_delay((uint8_t)k_pdg_demo_channel, k_ra8_pdg_pin_a, k_ra8_pdg_edge_rising, &code);
  if (derr != k_ra8_ok) {
    return derr;
  }
  ra8_pdg_status_full_t st  = {};
  const ra8_err_t       err = ra8_pdg_get_status_full(&st);
  if (err != k_ra8_ok) {
    return err;
  }
  /* GTDLYRnA is not read-exposed on RA8D2 silicon: a write stages the delay
   * but the register reads back its 0x0000 reset value (confirmed by a debugger
   * probe; FSP never reads it back either). ra8_emulator shadows it as plain R/W,
   * which is why the read-back only appears to work there. So this is recorded
   * for the emulator but NOT gated on. */
  g_pdg_delay_readback = (uint32_t)code;
  g_pdg_dll            = (st.dll_enabled != 0U) ? 1U : 0U;
 
  const uint8_t powered  = (st.per_channel_powered[k_pdg_demo_channel] != 0U) ? 1U : 0U;
  const uint8_t bypass_n = (st.per_channel_bypass_off[k_pdg_demo_channel] != 0U) ? 1U : 0U;
  /* Validate the software-observable bring-up: DLL locked + channel 0 powered
   * and un-bypassed. The delay's actual edge-shift effect needs a scope. */
  *out_ok = (st.dll_enabled != 0U && powered != 0U && bypass_n != 0U) ? 1U : 0U;
  return k_ra8_ok;
}
 
void main(void)
{
  internal_pdg_demo_setup_or_halt();
  /* Clear PRIMASK so SysTick can dispatch and ra8_delay_ms() uses the
   * SysTick path (ra8_emulator does not advance DWT_CYCCNT). No NVIC sources
   * are armed by this demo. */
  ra8_isr_globals_enable();
 
  if (internal_pdg_demo_configure() != k_ra8_ok) {
    internal_pdg_demo_panic_halt();
  }
 
  while (1) {
    uint8_t         ok   = 0U;
    const ra8_err_t err  = internal_pdg_demo_sample(&ok);
    const uint8_t   good = (err == k_ra8_ok && ok != 0U) ? 1U : 0U;
    g_pdg_cfg_ok         = (uint32_t)good;
    if (good != 0U) {
      (void)ra8_board_uart_console_write(s_pdg_demo_ok_msg,
                                         (size_t)(sizeof(s_pdg_demo_ok_msg) - 1U));
      (void)ra8_board_led_toggle(k_ra8_board_led1);
    } else {
      (void)ra8_board_uart_console_write(s_pdg_demo_bad_msg,
                                         (size_t)(sizeof(s_pdg_demo_bad_msg) - 1U));
      (void)ra8_board_led_toggle(k_ra8_board_led2);
    }
    ++g_pdg_heartbeat;
    ra8_delay_ms(k_pdg_demo_period_ms);
  }
  internal_pdg_demo_panic_halt();
}