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_elc.h"
#include "ra8_elc_regs.h"
#include "ra8_err.h"
#include "ra8_isr.h"
#include "ra8_mstp.h"
#include "ra8_time.h"

typedef enum : uint32_t {
  k_elc_demo_baud      = 115200U, 
  k_elc_demo_period_ms = 1000U,   
} elc_demo_const_t;

typedef enum : uint8_t {
  k_elc_demo_slot         = 0U,  
  k_elc_demo_sw_event_idx = 0U,  
  k_elc_demo_ascii_zero   = '0', 
  k_elc_demo_ascii_one    = '1', 
  k_elc_demo_dec_base     = 10U, 
  k_elc_demo_uint_dec_max = 10U, 
  k_elc_demo_print_buf    = 48U, 
} elc_demo_byte_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_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_elc_demo_baud) != k_ra8_ok) {
    internal_panic_halt();
  }
 
  if (ra8_elc_init() != k_ra8_ok) {
    internal_panic_halt();
  }
  /* Route IRQ0 -> ELSR0 so a real button press would chain a GPT
   * capture without CPU intervention; the software trigger below
   * keeps the demo self-contained. */
  if (ra8_elc_link((uint8_t)k_elc_demo_slot, k_ra8_elc_event_icu_irq0) != 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();
  }
}

RA8_INTERNAL static uint8_t internal_uint_to_dec(uint8_t* buf, uint32_t v)
{
  uint8_t  tmp[k_elc_demo_uint_dec_max];
  uint8_t  n = 0U;
  uint32_t r = v;
  if (r == 0U) {
    buf[0] = (uint8_t)k_elc_demo_ascii_zero;
    return 1U;
  }
  while ((r > 0U) && (n < (uint8_t)k_elc_demo_uint_dec_max)) {
    tmp[n] =
      (uint8_t)((uint8_t)k_elc_demo_ascii_zero + (uint8_t)(r % (uint32_t)k_elc_demo_dec_base));
    r = r / (uint32_t)k_elc_demo_dec_base;
    n++;
  }
  for (uint8_t i = 0U; i < n; i++) {
    buf[i] = tmp[(uint8_t)(n - 1U - i)];
  }
  return n;
}

RA8_INTERNAL static uint32_t internal_format_line(uint8_t* out, bool enabled, uint32_t trig_count)
{
  uint32_t      off      = 0U;
  const uint8_t prefix[] = "elc: en=";
  const uint8_t mid[]    = " trig=";
  const uint8_t suffix[] = "\r\n";
  for (uint32_t i = 0U; i < sizeof(prefix) - 1U; i++) {
    out[off++] = prefix[i];
  }
  out[off++] = enabled ? (uint8_t)k_elc_demo_ascii_one : (uint8_t)k_elc_demo_ascii_zero;
  for (uint32_t i = 0U; i < sizeof(mid) - 1U; i++) {
    out[off++] = mid[i];
  }
  off += internal_uint_to_dec(&out[off], trig_count);
  for (uint32_t i = 0U; i < sizeof(suffix) - 1U; i++) {
    out[off++] = suffix[i];
  }
  return off;
}

void main(void)
{
  internal_setup_or_halt();
  ra8_isr_globals_enable();
 
  uint32_t trig_count = 0U;
  while (1) {
    if (ra8_elc_software_trigger((uint8_t)k_elc_demo_sw_event_idx) != k_ra8_ok) {
      (void)ra8_board_led_on(k_ra8_board_led2);
      /* Emit FAIL banner so the HIL negative regex catches a silently
       * broken SW-trigger path; without this the t=N counter would
       * stop advancing but the demo would keep emitting "elc: en=1
       * t=0" indefinitely and the probe would pass. */
      const uint8_t trig_fail[] = "elc: FAIL trigger\r\n";
      (void)ra8_board_uart_console_write(trig_fail, (size_t)(sizeof(trig_fail) - 1U));
    } else {
      trig_count++;
    }
    bool enabled = false;
    if (ra8_elc_is_enabled(&enabled) != k_ra8_ok) {
      (void)ra8_board_led_on(k_ra8_board_led2);
      const uint8_t enabled_fail[] = "elc: FAIL is_enabled\r\n";
      (void)ra8_board_uart_console_write(enabled_fail, (size_t)(sizeof(enabled_fail) - 1U));
    }
    uint8_t        out[k_elc_demo_print_buf] = {};
    const uint32_t off                       = internal_format_line(out, enabled, trig_count);
    if (ra8_board_uart_console_write(out, (size_t)off) != k_ra8_ok) {
      break;
    }
    if (ra8_board_led_toggle(k_ra8_board_led1) != k_ra8_ok) {
      break;
    }
    ra8_delay_ms(k_elc_demo_period_ms);
  }
 
  internal_panic_halt();
}