main.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "ra8_agt.h"
#include "ra8_agt_regs.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_time.h"

typedef enum : uint32_t {
  k_agt_cas_baud    = 115200U, 
  k_agt_cas_poll_ms = 10U,     
  /* 32-bit virtual reload. Low 16 bits go to AGT0, high 16 bits to
   * AGT1. Keep it small enough that AGT1 underflows within the HIL
   * timeout but large enough to demonstrate the cascade chain. */
  k_agt_cas_reload32 = 0x00017FFFU, 
} agt_cas_const_t;

typedef enum : uint32_t {
  k_agt_cas_hex_digits = 8U,   
  k_agt_cas_hex_shift  = 4U,   
  k_agt_cas_hex_mask   = 0xFU, 
} agt_cas_fmt_t;

typedef enum : uint8_t {
  k_agt_cas_hi_channel = 1U, 
} agt_cas_chan_t;

static const char s_agt_cas_hex_chars[] = "0123456789ABCDEF";

static const uint8_t s_agt_cas_msg_head[] = "agt_cas: tick=";
static const uint8_t s_agt_cas_msg_tail[] = "\r\n";

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

RA8_INTERNAL static void internal_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    internal_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    internal_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    internal_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_agt_cas_baud) != k_ra8_ok) {
    internal_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    internal_panic_halt();
  }
}

[[nodiscard]] RA8_INTERNAL static ra8_err_t internal_arm(void)
{
  const ra8_agt_cascade_cfg_t cfg = {
    .reload32     = (uint32_t)k_agt_cas_reload32,
    .clock        = k_ra8_agt_cascade_clk_pclkb,
    .on_underflow = nullptr,
    .ctx          = nullptr,
  };
  return ra8_agt_start_cascade(&cfg);
}

RA8_INTERNAL static void internal_format_tick(uint32_t tick, uint8_t* digits)
{
  for (uint32_t i = 0U; i < (uint32_t)k_agt_cas_hex_digits; ++i) {
    const uint32_t shift =
      ((uint32_t)k_agt_cas_hex_digits - 1U - i) * (uint32_t)k_agt_cas_hex_shift;
    const uint32_t nib = (tick >> shift) & (uint32_t)k_agt_cas_hex_mask;
    digits[i]          = (uint8_t)s_agt_cas_hex_chars[nib];
  }
}

[[nodiscard]] RA8_INTERNAL static ra8_err_t internal_emit_tick(uint32_t tick)
{
  uint8_t digits[k_agt_cas_hex_digits] = {};
  internal_format_tick(tick, digits);
  ra8_err_t err =
    ra8_board_uart_console_write(s_agt_cas_msg_head, (size_t)(sizeof(s_agt_cas_msg_head) - 1U));
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_board_uart_console_write(digits, (size_t)sizeof(digits));
  if (err != k_ra8_ok) {
    return err;
  }
  return ra8_board_uart_console_write(s_agt_cas_msg_tail,
                                      (size_t)(sizeof(s_agt_cas_msg_tail) - 1U));
}
 
void main(void)
{
  internal_setup_or_halt();
  ra8_isr_globals_enable();
 
  if (internal_arm() != k_ra8_ok) {
    internal_panic_halt();
  }
 
  uint32_t tick = 0U;
  while (1) {
    uint8_t status = 0U;
    if (ra8_agt_get_status((uint8_t)k_agt_cas_hi_channel, &status) != k_ra8_ok) {
      break;
    }
    if ((status & (uint8_t)k_ra8_agt_agtcr_tundf_msk) != 0U) {
      if (ra8_board_led_toggle(k_ra8_board_led1) != k_ra8_ok) {
        break;
      }
      ++tick;
      if (internal_emit_tick(tick) != k_ra8_ok) {
        break;
      }
      /* Stop both halves + re-arm to clear AGT1.AGTCR.TUNDF. */
      if (ra8_agt_stop(0U) != k_ra8_ok) {
        break;
      }
      if (ra8_agt_stop((uint8_t)k_agt_cas_hi_channel) != k_ra8_ok) {
        break;
      }
      if (internal_arm() != k_ra8_ok) {
        break;
      }
    }
    ra8_delay_ms((uint32_t)k_agt_cas_poll_ms);
  }
  internal_panic_halt();
}