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_isr.h"
#include "ra8_systick.h"
#include "ra8_time.h"

typedef enum : uint32_t {
  k_demo_baud       = 115200U,  
  k_demo_period_ms  = 1000U,    
  k_demo_tick_hz    = 1000U,    
  k_demo_u32_digits = 10U,      
  k_demo_hz_per_mhz = 1000000U, 
  k_demo_dec_base   = 10U,      
} hal_timebase_config_t;

static const uint8_t k_demo_lbl_reload[] = "reload=";
static const uint8_t k_demo_lbl_ms[] = "hal timebase ms=";
static const uint8_t k_demo_lbl_cycles[] = " cycles=";
static const uint8_t k_demo_lbl_us[] = " us=";
static const uint8_t k_demo_crlf[] = "\r\n";

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

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

static void demo_emit_u32(uint32_t value)
{
  uint8_t  buf[k_demo_u32_digits];
  uint32_t idx = (uint32_t)k_demo_u32_digits;
 
  if (value == 0U) {
    idx--;
    buf[idx] = (uint8_t)'0';
  } else {
    for (uint32_t d = 0U; d < (uint32_t)k_demo_u32_digits; d++) {
      if (value == 0U) {
        break;
      }
      idx--;
      buf[idx] = (uint8_t)('0' + (uint8_t)(value % (uint32_t)k_demo_dec_base));
      value /= (uint32_t)k_demo_dec_base;
    }
  }
 
  demo_emit(&buf[idx], (size_t)((uint32_t)k_demo_u32_digits - idx));
}

static ra8_err_t demo_setup_or_halt(uint32_t* out_cpuclk_hz)
{
  if (out_cpuclk_hz == nullptr) {
    return k_ra8_err_invalid_arg;
  }
 
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    demo_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    demo_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    demo_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_demo_baud) != k_ra8_ok) {
    demo_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    demo_panic_halt();
  }
 
  /* The timebase primitive owns the DWT enable and the SysTick arithmetic. */
  ra8_dwt_cyccnt_enable();
 
  uint32_t reload = 0U;
  if (ra8_systick_reload_for(cpuclk0_hz, (uint32_t)k_demo_tick_hz, &reload) != k_ra8_ok) {
    demo_panic_halt();
  }
  /* Re-arm the SAME SysTick via the HAL path: same reload + control bits the
   * raw ra8_time_init() programmed, so ra8_delay_ms() keeps ticking. */
  if (ra8_systick_configure(reload, k_ra8_systick_clk_cpu, true) != k_ra8_ok) {
    demo_panic_halt();
  }
 
  demo_emit(k_demo_lbl_reload, sizeof(k_demo_lbl_reload) - 1U);
  demo_emit_u32(reload);
  demo_emit(k_demo_crlf, sizeof(k_demo_crlf) - 1U);
 
  *out_cpuclk_hz = cpuclk0_hz;
  return k_ra8_ok;
}

static void demo_emit_measurement(uint32_t cpuclk_hz)
{
  uint32_t cycles_per_us = cpuclk_hz / (uint32_t)k_demo_hz_per_mhz;
  if (cycles_per_us == 0U) {
    cycles_per_us = 1U;
  }
 
  ra8_dwt_cyccnt_reset();
  ra8_delay_ms((uint32_t)k_demo_period_ms);
  const uint32_t cycles = ra8_dwt_cyccnt_read();
  const uint32_t micros = cycles / cycles_per_us;
 
  demo_emit(k_demo_lbl_ms, sizeof(k_demo_lbl_ms) - 1U);
  demo_emit_u32((uint32_t)k_demo_period_ms);
  demo_emit(k_demo_lbl_cycles, sizeof(k_demo_lbl_cycles) - 1U);
  demo_emit_u32(cycles);
  demo_emit(k_demo_lbl_us, sizeof(k_demo_lbl_us) - 1U);
  demo_emit_u32(micros);
  demo_emit(k_demo_crlf, sizeof(k_demo_crlf) - 1U);
}

void main(void)
{
  uint32_t cpuclk0_hz = 0U;
  if (demo_setup_or_halt(&cpuclk0_hz) != k_ra8_ok) {
    demo_panic_halt();
  }
 
  ra8_isr_globals_enable();
 
  while (1) {
    demo_emit_measurement(cpuclk0_hz);
    if (ra8_board_led_toggle(k_ra8_board_led1) != k_ra8_ok) {
      break;
    }
  }
 
  demo_panic_halt();
}