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_cac.h"
#include "ra8_cac_regs.h"
#include "ra8_cgc.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_isr.h"
#include "ra8_mstp.h"
#include "ra8_time.h"

static const char* s_tag = "cac_demo";

typedef enum : uint32_t {
  k_cac_demo_baud      = 115200U, 
  k_cac_demo_period_ms = 1000U,   
} cac_demo_config_t;

typedef enum : uint32_t {
  k_cac_demo_main_hz   = 24000000U, 
  k_cac_demo_loco_hz   = 32768U,    
  k_cac_demo_ref_div   = 32U,       
  k_cac_demo_tol_shift = 4U,        
} cac_demo_calc_t;

typedef enum : uint8_t {
  k_cac_demo_cacr1_main = 0x00U, 
  k_cac_demo_cacr2_loco = 0x09U, 
} cac_demo_cacr_t;

static const uint8_t s_cac_demo_ok_msg[]  = "cac: meas=ok ferr=0 ovf=0 ok=Y\r\n";
static const uint8_t s_cac_demo_bad_msg[] = "cac: meas=TIMEOUT-or-err ok=N\r\n";

volatile uint32_t g_cac_count = 0U;

volatile uint32_t g_cac_ok = 0U;

volatile uint32_t g_cac_status = 0U;

volatile uint32_t g_cac_heartbeat = 0U;

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

RA8_INTERNAL static uint32_t internal_expected(void)
{
  return ((uint32_t)k_cac_demo_main_hz * (uint32_t)k_cac_demo_ref_div) /
         (uint32_t)k_cac_demo_loco_hz;
}

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_mstp_init() != 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_cac_demo_baud) != k_ra8_ok) {
    internal_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    internal_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led2) != k_ra8_ok) {
    internal_panic_halt();
  }
}

[[nodiscard]] RA8_INTERNAL static ra8_err_t internal_configure(void)
{
  const uint32_t expected = internal_expected();
  const uint32_t tol      = expected >> (uint32_t)k_cac_demo_tol_shift;
  const uint16_t upper    = (uint16_t)(expected + tol);
  const uint16_t lower    = (uint16_t)(expected - tol);
 
  const ra8_err_t err = ra8_cac_init(upper, lower);
  if (err != k_ra8_ok) {
    return err;
  }
  /* HUM Ch 10.2.2 "CACR1 : CAC Control Register 1" p 422 -- target =
   * main osc (FMCS=000), no division, rising edge. Valid while CFME=0. */
  ra8_cac()->CACR1 = (uint8_t)k_cac_demo_cacr1_main;
  /* HUM Ch 10.2.3 "CACR2 : CAC Control Register 2" p 423 -- internal
   * reference = LOCO (RSCS=100) divided by 32 (RCDS=00), no filter. */
  ra8_cac()->CACR2 = (uint8_t)k_cac_demo_cacr2_loco;
  return k_ra8_ok;
}

[[nodiscard]] RA8_INTERNAL static ra8_err_t internal_sample(uint8_t* out_ok)
{
  RA8_CHECK_NULL_PTR(out_ok, s_tag, "out_ok must not be nullptr");
 
  uint16_t        count   = 0U;
  const ra8_err_t meas    = ra8_cac_measure(&count);
  const uint8_t   meas_ok = (meas == k_ra8_ok) ? 1U : 0U;
 
  uint8_t         status = 0U;
  const ra8_err_t serr   = ra8_cac_get_status(&status);
  if (serr != k_ra8_ok) {
    return serr;
  }
  g_cac_status = (uint32_t)status;
  if (meas_ok != 0U) {
    g_cac_count = (uint32_t)count;
  }
  const uint8_t ferrf = ((status & (uint8_t)k_ra8_cac_status_ferrf) != 0U) ? 1U : 0U;
  const uint8_t ovff  = ((status & (uint8_t)k_ra8_cac_status_ovff) != 0U) ? 1U : 0U;
  *out_ok             = (meas_ok != 0U && ferrf == 0U && ovff == 0U) ? 1U : 0U;
  return k_ra8_ok;
}
 
void main(void)
{
  internal_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_configure() != k_ra8_ok) {
    internal_panic_halt();
  }
 
  while (1) {
    uint8_t         ok   = 0U;
    const ra8_err_t err  = internal_sample(&ok);
    const uint8_t   good = (err == k_ra8_ok && ok != 0U) ? 1U : 0U;
    g_cac_ok             = (uint32_t)good;
    if (good != 0U) {
      (void)ra8_board_uart_console_write(s_cac_demo_ok_msg,
                                         (size_t)(sizeof(s_cac_demo_ok_msg) - 1U));
      (void)ra8_board_led_toggle(k_ra8_board_led1);
    } else {
      (void)ra8_board_uart_console_write(s_cac_demo_bad_msg,
                                         (size_t)(sizeof(s_cac_demo_bad_msg) - 1U));
      (void)ra8_board_led_toggle(k_ra8_board_led2);
    }
    ++g_cac_heartbeat;
    ra8_delay_ms(k_cac_demo_period_ms);
  }
  internal_panic_halt();
}