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

typedef enum : uint32_t {
  k_gpt_capture_period         = 0xFFFFFFFFUL, 
  k_gpt_capture_poll_period_ms = 10U,          
  k_gpt_capture_min_delta_ms   = 50U,          
} gpt_capture_const_t;

volatile uint32_t g_gpt_capture_tick = 0U;

typedef enum : uint8_t {
  k_gpt_capture_channel = 0U, 
} gpt_capture_layout_t;

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_led_init(k_ra8_board_led1) != k_ra8_ok) {
    internal_panic_halt();
  }
  if (ra8_board_sw_init(k_ra8_board_sw1) != k_ra8_ok) {
    internal_panic_halt();
  }
  const ra8_gpt_cfg_t cfg = {
    .mode       = k_ra8_gpt_mode_saw_pwm,
    .prescaler  = k_ra8_gpt_ps_div_64,
    .period     = (uint32_t)k_gpt_capture_period,
    .duty_a     = 0U,
    .duty_b     = 0U,
    .auto_start = true,
  };
  if (ra8_gpt_init((uint8_t)k_gpt_capture_channel, &cfg) != k_ra8_ok) {
    internal_panic_halt();
  }
}

RA8_INTERNAL static uint32_t internal_read(void)
{
  uint32_t val = 0U;
  if (ra8_gpt_read((uint8_t)k_gpt_capture_channel, &val) != k_ra8_ok) {
    return UINT32_MAX;
  }
  return val;
}

RA8_INTERNAL static bool internal_edge(ra8_board_sw_state_t* prev)
{
  ra8_board_sw_state_t now = k_ra8_board_sw_released;
  if (ra8_board_sw_read(k_ra8_board_sw1, &now) != k_ra8_ok) {
    return false;
  }
  bool fell = (*prev == k_ra8_board_sw_released) && (now == k_ra8_board_sw_pressed);
  *prev     = now;
  return fell;
}

void main(void)
{
  internal_setup_or_halt();
  ra8_isr_globals_enable();
 
  ra8_board_sw_state_t last_state = k_ra8_board_sw_released;
  uint32_t             last_tick  = 0U;
  uint32_t             prev_count = 0U;
  bool                 have_prev  = false;
 
  while (1) {
    if (internal_edge(&last_state)) {
      const uint32_t now        = internal_read();
      const uint32_t last_delta = now - last_tick;
      last_tick                 = now;
      (void)last_delta;
      (void)ra8_board_led_toggle(k_ra8_board_led1);
    }
    /* Liveness check independent of SW1 -- proves GTCNT is counting
     * even when the button isn't pressed (which it never is on the
     * unattended HIL bench). */
    const uint32_t now_count = internal_read();
    if (now_count != UINT32_MAX) {
      if (have_prev && (now_count != prev_count)) {
        g_gpt_capture_tick += 1U;
      }
      prev_count = now_count;
      have_prev  = true;
    }
    ra8_delay_ms(k_gpt_capture_poll_period_ms);
  }
  internal_panic_halt();
}