main.c

Go to the documentation of this file.

 
#include <stdint.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_mstp.h"
#include "ra8_time.h"

typedef enum : uint32_t {
  k_timer_demo_baud        = 115200U,      
  k_timer_demo_period_ms   = 1000U,        
  k_timer_demo_capture_ms  = 50U,          
  k_timer_demo_gpt_channel = 0U,           
  k_timer_demo_gpt_period  = 0xFFFFFFFFUL, 
} timer_demo_config_t;

typedef enum : uint8_t {
  k_timer_demo_nibble_mask  = 0x0FU, 
  k_timer_demo_nibble_shift = 4U,    
  k_timer_demo_alpha_thresh = 10U,   
  k_timer_demo_hex_per_word = 8U,    
} timer_demo_byte_t;

static const uint8_t k_timer_demo_prefix[] = "gpt: period=";
static const uint8_t k_timer_demo_eol[]    = "\r\n";

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

static uint8_t timer_demo_nibble_to_hex(uint8_t nibble)
{
  uint8_t n = (uint8_t)(nibble & (uint8_t)k_timer_demo_nibble_mask);
  if (n < (uint8_t)k_timer_demo_alpha_thresh) {
    return (uint8_t)('0' + n);
  }
  return (uint8_t)('a' + (n - (uint8_t)k_timer_demo_alpha_thresh));
}

static void timer_demo_word_to_hex(uint32_t v, uint8_t* dst)
{
  for (uint8_t i = 0U; i < (uint8_t)k_timer_demo_hex_per_word; ++i) {
    const uint8_t shift =
      (uint8_t)(((uint8_t)k_timer_demo_hex_per_word - 1U - i) * (uint8_t)k_timer_demo_nibble_shift);
    const uint8_t nibble = (uint8_t)((v >> shift) & (uint32_t)k_timer_demo_nibble_mask);
    dst[i]               = timer_demo_nibble_to_hex(nibble);
  }
}

static uint32_t timer_demo_delta(uint32_t start, uint32_t stop)
{
  if (stop >= start) {
    return stop - start;
  }
  return (uint32_t)k_timer_demo_gpt_period - start + stop + 1U;
}

static void timer_demo_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
 
  if (ra8_cgc_init() != k_ra8_ok) {
    timer_demo_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    timer_demo_panic_halt();
  }
  if (ra8_mstp_init() != k_ra8_ok) {
    timer_demo_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    timer_demo_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_timer_demo_baud) != k_ra8_ok) {
    timer_demo_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    timer_demo_panic_halt();
  }
  if (ra8_gpt_start_free_run((uint8_t)k_timer_demo_gpt_channel,
                             (uint32_t)k_timer_demo_gpt_period) != k_ra8_ok) {
    timer_demo_panic_halt();
  }
}

[[nodiscard]] static ra8_err_t timer_demo_one_capture(void)
{
  uint32_t start = 0U;
  uint32_t stop  = 0U;
 
  if (ra8_gpt_read((uint8_t)k_timer_demo_gpt_channel, &start) != k_ra8_ok) {
    return k_ra8_err_hw_error;
  }
  (void)ra8_board_led_toggle(k_ra8_board_led1);
  ra8_delay_ms((uint32_t)k_timer_demo_capture_ms);
  if (ra8_gpt_read((uint8_t)k_timer_demo_gpt_channel, &stop) != k_ra8_ok) {
    return k_ra8_err_hw_error;
  }
 
  const uint32_t delta                          = timer_demo_delta(start, stop);
  uint8_t        hex[k_timer_demo_hex_per_word] = {};
  timer_demo_word_to_hex(delta, hex);
 
  if (ra8_board_uart_console_write(k_timer_demo_prefix,
                                   (size_t)(sizeof(k_timer_demo_prefix) - 1U)) != k_ra8_ok) {
    return k_ra8_err_hw_error;
  }
  if (ra8_board_uart_console_write(hex, (size_t)k_timer_demo_hex_per_word) != k_ra8_ok) {
    return k_ra8_err_hw_error;
  }
  return ra8_board_uart_console_write(k_timer_demo_eol, (size_t)(sizeof(k_timer_demo_eol) - 1U));
}
 
void main(void)
{
  timer_demo_setup_or_halt();
  ra8_isr_globals_enable();
 
  while (1) {
    if (timer_demo_one_capture() != k_ra8_ok) {
      break;
    }
    ra8_delay_ms((uint32_t)k_timer_demo_period_ms);
  }
  timer_demo_panic_halt();
}