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

typedef enum : uint32_t {
  k_gptp_baud      = 115200U,    
  k_gptp_period_ms = 1000U,      
  k_gptp_window_ms = 500U,       
  k_gptp_base_sec  = 1000000000U 
} gptp_const_t;

typedef enum : uint64_t {
  k_gptp_sec_flatten_max = 18446744073ULL, 
} gptp_flatten_limit_t;

typedef enum : uint32_t {
  k_gptp_radix       = 10U,        
  k_gptp_dec_u64_max = 20U,        
  k_gptp_ns_per_ms   = 1000000U,   
  k_gptp_ns_per_sec  = 1000000000U 
} gptp_fmt_t;

typedef enum : uint8_t {
  k_gptp_tolerance_pct = 10U,  
  k_gptp_pct_full      = 100U, 
} gptp_band_t;
 
/* Console line fragments (kept short so each write is one shift-register
 * fill; the periodic log is the only output path). */
static const uint8_t k_gptp_ipv_prefix[]   = "gptp: ipv=";
static const uint8_t k_gptp_time_prefix[]  = "gptp: t=";
static const uint8_t k_gptp_time_dot[]     = ".";
static const uint8_t k_gptp_adv_prefix[]   = "gptp: adv_ns=";
static const uint8_t k_gptp_sys_prefix[]   = " sys_ms=";
static const uint8_t k_gptp_crlf[]         = "\r\n";
static const uint8_t k_gptp_verdict_pass[] = "gptp: clock PASS\r\n";
static const uint8_t k_gptp_verdict_fail[] = "gptp: clock FAIL\r\n";

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

static void gptp_write(const uint8_t* data, uint32_t len)
{
  (void)ra8_board_uart_console_write(data, (size_t)len);
}

static void gptp_write_u64(uint64_t val)
{
  uint8_t  buf[k_gptp_dec_u64_max];
  uint8_t  tmp[k_gptp_dec_u64_max];
  uint32_t n = 0U;
  uint64_t v = val;
  if (v == 0U) {
    buf[0] = (uint8_t)'0';
    gptp_write(buf, 1U);
    return;
  }
  while (v != 0U) {
    tmp[n] = (uint8_t)('0' + (uint8_t)(v % (uint64_t)k_gptp_radix));
    v      = v / (uint64_t)k_gptp_radix;
    n++;
  }
  for (uint32_t i = 0U; i < n; i++) {
    buf[i] = tmp[n - 1U - i];
  }
  gptp_write(buf, n);
}

static void gptp_log_time(uint64_t sec, uint32_t nsec)
{
  gptp_write(k_gptp_time_prefix, (uint32_t)(sizeof(k_gptp_time_prefix) - 1U));
  gptp_write_u64(sec);
  gptp_write(k_gptp_time_dot, (uint32_t)(sizeof(k_gptp_time_dot) - 1U));
  gptp_write_u64((uint64_t)nsec);
  gptp_write(k_gptp_crlf, (uint32_t)(sizeof(k_gptp_crlf) - 1U));
}

static uint64_t gptp_flatten_ns(uint64_t sec, uint32_t nsec)
{
  if (sec > (uint64_t)k_gptp_sec_flatten_max) {
    return UINT64_MAX;
  }
  return (sec * (uint64_t)k_gptp_ns_per_sec) + (uint64_t)nsec;
}

static bool gptp_probe_presence(void)
{
  uint32_t        version = 0U;
  const ra8_err_t err     = ra8_eth_gptp_ip_version(&version);
  gptp_write(k_gptp_ipv_prefix, (uint32_t)(sizeof(k_gptp_ipv_prefix) - 1U));
  gptp_write_u64((uint64_t)version);
  gptp_write(k_gptp_crlf, (uint32_t)(sizeof(k_gptp_crlf) - 1U));
  if (err != k_ra8_ok) {
    return false;
  }
  return version != 0U;
}

static bool gptp_advance_ok(uint64_t advance_ns, uint32_t elapsed_ms)
{
  if (elapsed_ms == 0U) {
    return false;
  }
  const uint64_t expected_ns = (uint64_t)elapsed_ms * (uint64_t)k_gptp_ns_per_ms;
  const uint64_t band_ns =
    (expected_ns * (uint64_t)k_gptp_tolerance_pct) / (uint64_t)k_gptp_pct_full;
  if (advance_ns > (expected_ns + band_ns)) {
    return false;
  }
  return advance_ns >= (expected_ns - band_ns);
}

static bool gptp_measure(void)
{
  uint64_t sec0  = 0U;
  uint32_t nsec0 = 0U;
  uint64_t sec1  = 0U;
  uint32_t nsec1 = 0U;
  bool     ok    = true;
 
  const uint32_t ms0 = ra8_time_ms();
  if (ra8_eth_gptp_get_time(k_ra8_gptp_timer_0, &sec0, &nsec0) != k_ra8_ok) {
    ok = false;
  }
  ra8_delay_ms((uint32_t)k_gptp_window_ms);
  if (ra8_eth_gptp_get_time(k_ra8_gptp_timer_0, &sec1, &nsec1) != k_ra8_ok) {
    ok = false;
  }
  const uint32_t elapsed_ms = ra8_time_ms() - ms0;
 
  gptp_log_time(sec0, nsec0);
  gptp_log_time(sec1, nsec1);
 
  const uint64_t ns0        = gptp_flatten_ns(sec0, nsec0);
  const uint64_t ns1        = gptp_flatten_ns(sec1, nsec1);
  const uint64_t advance_ns = (ns1 > ns0) ? (ns1 - ns0) : 0ULL;
 
  gptp_write(k_gptp_adv_prefix, (uint32_t)(sizeof(k_gptp_adv_prefix) - 1U));
  gptp_write_u64(advance_ns);
  gptp_write(k_gptp_sys_prefix, (uint32_t)(sizeof(k_gptp_sys_prefix) - 1U));
  gptp_write_u64((uint64_t)elapsed_ms);
  gptp_write(k_gptp_crlf, (uint32_t)(sizeof(k_gptp_crlf) - 1U));
 
  if (!gptp_advance_ok(advance_ns, elapsed_ms)) {
    ok = false;
  }
  return ok;
}

static bool gptp_run_cycle(void)
{
  bool ok = true;
  if (!gptp_probe_presence()) {
    ok = false;
  }
  if (!gptp_measure()) {
    ok = false;
  }
  return ok;
}

static void gptp_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    gptp_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    gptp_panic_halt();
  }
  if (ra8_mstp_init() != k_ra8_ok) {
    gptp_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    gptp_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_gptp_baud) != k_ra8_ok) {
    gptp_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    gptp_panic_halt();
  }
  if (ra8_cgc_eswclk_init() != k_ra8_ok) {
    gptp_panic_halt();
  }
}

[[nodiscard]] static ra8_err_t gptp_arm(void)
{
  uint32_t        eswclk_hz = 0U;
  const ra8_err_t hz_err    = ra8_cgc_eswclk_hz(&eswclk_hz);
  if (hz_err != k_ra8_ok) {
    return hz_err;
  }
  const ra8_eth_gptp_cfg_t cfg      = {.clk_hz = eswclk_hz};
  const ra8_err_t          init_err = ra8_eth_gptp_init(&cfg);
  if (init_err != k_ra8_ok) {
    return init_err;
  }
  const ra8_err_t off_err =
    ra8_eth_gptp_set_offset(k_ra8_gptp_timer_0, (uint64_t)k_gptp_base_sec, 0U);
  if (off_err != k_ra8_ok) {
    return off_err;
  }
  return ra8_eth_gptp_timer_enable(k_ra8_gptp_timer_0);
}
 
void main(void)
{
  gptp_setup_or_halt();
  ra8_isr_globals_enable();
 
  if (gptp_arm() != k_ra8_ok) {
    gptp_panic_halt();
  }
 
  while (1) {
    const bool healthy = gptp_run_cycle();
    if (healthy) {
      gptp_write(k_gptp_verdict_pass, (uint32_t)(sizeof(k_gptp_verdict_pass) - 1U));
    } else {
      gptp_write(k_gptp_verdict_fail, (uint32_t)(sizeof(k_gptp_verdict_fail) - 1U));
    }
    if (ra8_board_led_toggle(k_ra8_board_led1) != k_ra8_ok) {
      break;
    }
    ra8_delay_ms((uint32_t)k_gptp_period_ms);
  }
  gptp_panic_halt();
}