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

typedef enum : uint32_t {
  k_audio_loopback_baud         = 115200U, 
  k_audio_loopback_print_period = 1000U,   
  k_audio_loopback_sample_rate  = 48000U,  
} audio_loopback_config_t;

typedef enum : uint8_t {
  k_audio_loopback_bit_depth = 16U, 
  k_audio_loopback_channels  = 2U,  
} audio_loopback_chan_t;

typedef enum : uint32_t {
  k_audio_loopback_block_samples = 128U, 
} audio_loopback_block_t;

static const uint8_t s_audio_loopback_msg_prefix[] = "audio: ";
static const uint8_t s_audio_loopback_msg_suffix[] = " blocks played\r\n";

static const int16_t s_audio_loopback_silence[k_audio_loopback_block_samples] = {};

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

RA8_INTERNAL static void internal_audio_loopback_init_clocks_and_led(void)
{
  uint32_t cpuclk0_hz = 0U;
 
  if (ra8_cgc_init() != k_ra8_ok) {
    internal_audio_loopback_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    internal_audio_loopback_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    internal_audio_loopback_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    internal_audio_loopback_panic_halt();
  }
}

RA8_INTERNAL static void internal_audio_loopback_init_console(void)
{
  if (ra8_board_uart_console_init((uint32_t)k_audio_loopback_baud) != k_ra8_ok) {
    internal_audio_loopback_panic_halt();
  }
}

RA8_INTERNAL static void internal_audio_loopback_init_codec(void)
{
  const ra8_err_t err = ra8_board_audio_init(k_audio_loopback_sample_rate,
                                             (uint8_t)k_audio_loopback_bit_depth,
                                             (uint8_t)k_audio_loopback_channels);
  if (err != k_ra8_ok) {
    internal_audio_loopback_panic_halt();
  }
}

RA8_INTERNAL static uint32_t internal_audio_loopback_u32_to_dec(uint32_t value, uint8_t* buf)
{
  enum : uint8_t {
    k_ascii_zero = 0x30U, 
    k_radix      = 10U,   
    k_max_digits = 10U,   
  };
  uint8_t  tmp[k_max_digits];
  uint32_t n = 0U;
  if (value == 0U) {
    buf[0] = k_ascii_zero;
    return 1U;
  }
  while (value > 0U) {
    tmp[n] = (uint8_t)(k_ascii_zero + (uint8_t)(value % k_radix));
    n++;
    value /= k_radix;
  }
  for (uint32_t i = 0U; i < n; i++) {
    buf[i] = tmp[n - 1U - i];
  }
  return n;
}

RA8_INTERNAL static void internal_audio_loopback_print_count(uint32_t block_count)
{
  enum : uint8_t {
    k_dec_buf = 12U, 
  };
  uint8_t  digits[k_dec_buf];
  uint32_t n = internal_audio_loopback_u32_to_dec(block_count, digits);
 
  (void)ra8_board_uart_console_write(s_audio_loopback_msg_prefix,
                                     (size_t)(sizeof(s_audio_loopback_msg_prefix) - 1U));
  (void)ra8_board_uart_console_write(digits, (size_t)n);
  (void)ra8_board_uart_console_write(s_audio_loopback_msg_suffix,
                                     (size_t)(sizeof(s_audio_loopback_msg_suffix) - 1U));
}

void main(void)
{
  internal_audio_loopback_init_clocks_and_led();
  internal_audio_loopback_init_console();
  internal_audio_loopback_init_codec();
 
  ra8_isr_globals_enable();
 
  uint32_t block_count = 0U;
 
  while (1) {
    if (ra8_board_audio_play_sample_block(s_audio_loopback_silence,
                                          k_audio_loopback_block_samples) != k_ra8_ok) {
      break;
    }
    block_count++;
    if ((block_count % k_audio_loopback_print_period) == 0U) {
      internal_audio_loopback_print_count(block_count);
      (void)ra8_board_led_toggle(k_ra8_board_led1);
    }
  }
 
  internal_audio_loopback_panic_halt();
}