main.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "ra8_audio.h"
#include "ra8_audio_source_pdm.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_err.h"
#include "ra8_mstp.h"
#include "ra8_time.h"
 
/* =============================================================================
 * App-wide tunables
 * =============================================================================
 */

typedef enum : uint32_t {
  k_pdm_demo_baud       = 115200U, 
  k_pdm_demo_decimal    = 10U,     
  k_pdm_demo_settle_ms  = 300U,    
  k_pdm_demo_window     = 256U,    
  k_pdm_demo_discard    = 1024U,   
  k_pdm_demo_report_win = 8U,      
  k_pdm_demo_poll_max   = 500000U, 
} pdm_demo_const_t;

typedef enum : int32_t {
  k_pdm_demo_min_span  = 8,  
  k_pdm_demo_rms_floor = 16, 
} pdm_demo_threshold_t;

typedef enum : uint32_t {
  k_pdm_demo_int_str_cap = 12U, 
} pdm_demo_str_cap_t;

typedef enum : uint32_t {
  k_pdm_isqrt_steps = 32U, 
  k_pdm_isqrt_top2  = 62U, 
} pdm_isqrt_const_t;
 
/* =============================================================================
 * Captured-window metrics + J-Link-probable result
 * =============================================================================
 */

typedef struct {
  int32_t  min;  
  int32_t  max;  
  int32_t  mean; 
  int32_t  peak; 
  int32_t  rms;  
  uint32_t n;    
} pdm_metrics_t;

typedef struct {
  volatile uint32_t magic;   
  volatile int32_t  rms;     
  volatile int32_t  peak;    
  volatile int32_t  mean;    
  volatile int32_t  span;    
  volatile int32_t  vary;    
  volatile uint32_t samples; 
  volatile uint32_t active;  
  volatile uint32_t windows; 
  volatile uint32_t timestamp_ms;
} pdm_mic_result_t;

volatile pdm_mic_result_t g_pdm_mic_result;

static int32_t s_pdm_demo_buf[k_pdm_demo_window];

static ra8_audio_source_t s_pdm_demo_source;

static ra8_audio_source_pdm_state_t s_pdm_demo_source_state;

typedef enum : uint32_t {
  k_pdm_demo_magic = 0x50444D31U, 
} pdm_demo_magic_t;
 
/* =============================================================================
 * Banners
 * =============================================================================
 */
 
static const uint8_t k_pdm_demo_banner_init[]     = "pdm: init ch=2 clk=4mhz fs=16khz\r\n";
static const uint8_t k_pdm_demo_banner_fail[]     = "pdm: init FAIL\r\n";
static const uint8_t k_pdm_demo_banner_nodat[]    = "pdm: no data (FIFO empty) -- clock/mic?\r\n";
static const uint8_t k_pdm_demo_banner_pass[]     = "pdm: verdict=PASS active=Y\r\n";
static const uint8_t k_pdm_demo_banner_inactive[] = "pdm: verdict=FAIL active=N\r\n";
 
/* =============================================================================
 * Halt + tiny serialisers
 * =============================================================================
 */

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

static uint32_t pdm_demo_i32_to_dec(int32_t value, uint8_t* out)
{
  uint8_t  tmp[k_pdm_demo_int_str_cap] = {};
  uint32_t n                           = 0U;
  bool     neg                         = value < 0;
  /* Work in int64 so INT32_MIN negates without overflow. */
  int64_t v = value;
  if (neg) {
    v = -v;
  }
  if (v == 0) {
    tmp[n++] = (uint8_t)'0';
  } else {
    while (v > 0 && n < (uint32_t)k_pdm_demo_int_str_cap) {
      tmp[n++] = (uint8_t)('0' + (uint8_t)(v % (int64_t)k_pdm_demo_decimal));
      v /= (int64_t)k_pdm_demo_decimal;
    }
  }
  if (neg && n < (uint32_t)k_pdm_demo_int_str_cap) {
    tmp[n++] = (uint8_t)'-';
  }
  for (uint32_t i = 0U; i < n; ++i) {
    out[i] = tmp[n - 1U - i];
  }
  if (n < (uint32_t)k_pdm_demo_int_str_cap) {
    out[n] = 0U;
  }
  return n;
}

static uint32_t pdm_demo_isqrt(uint64_t value)
{
  uint64_t rem  = 0U;
  uint64_t root = 0U;
  for (int32_t i = 0; i < (int32_t)k_pdm_isqrt_steps; ++i) {
    root <<= 1;
    rem = (rem << 2) | (value >> (uint32_t)k_pdm_isqrt_top2);
    value <<= 2;
    ++root;
    if (root <= rem) {
      rem -= root;
      ++root;
    } else {
      --root;
    }
  }
  return (uint32_t)(root >> 1);
}

static void pdm_demo_tx(const uint8_t* bytes, uint32_t len)
{
  (void)ra8_board_uart_console_write(bytes, (size_t)len);
}

static void pdm_demo_emit_kv(const uint8_t* label, uint32_t label_len, int32_t value)
{
  uint8_t buf[k_pdm_demo_int_str_cap] = {};
  pdm_demo_tx(label, label_len);
  const uint32_t n = pdm_demo_i32_to_dec(value, buf);
  pdm_demo_tx(buf, n);
}
 
/* =============================================================================
 * Bring-up
 * =============================================================================
 */

static void pdm_demo_clocks_or_halt(void)
{
  ra8_board_clock_rates_t clock_rates = {};
  if (ra8_board_clocks_init(&clock_rates) != k_ra8_ok) {
    pdm_demo_panic_halt();
  }
  if (ra8_mstp_init() != k_ra8_ok) {
    pdm_demo_panic_halt();
  }
  if (ra8_time_init(clock_rates.cpuclk0_hz) != k_ra8_ok) {
    pdm_demo_panic_halt();
  }
}

static void pdm_demo_io_or_halt(void)
{
  if (ra8_board_pdm_mic_route() != k_ra8_ok) {
    pdm_demo_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_pdm_demo_baud) != k_ra8_ok) {
    pdm_demo_panic_halt();
  }
  (void)ra8_board_led_init(k_ra8_board_led1);
}

static void pdm_demo_pdm_or_halt(void)
{
  pdm_demo_tx(k_pdm_demo_banner_init, (uint32_t)(sizeof(k_pdm_demo_banner_init) - 1U));
  ra8_board_pdm_mic_config_t board_cfg = {};
  if (ra8_board_pdm_mic_get_config(k_ra8_board_pdm_mic1, &board_cfg) != k_ra8_ok) {
    pdm_demo_tx(k_pdm_demo_banner_fail, (uint32_t)(sizeof(k_pdm_demo_banner_fail) - 1U));
    pdm_demo_panic_halt();
  }
  const ra8_audio_source_pdm_cfg_t source_cfg = {
    .pdm               = board_cfg.pdm,
    .sample_rate_hz    = board_cfg.sample_rate_hz,
    .samples_per_frame = (uint32_t)k_pdm_demo_window,
    .settle_ms         = (uint32_t)k_pdm_demo_settle_ms,
    .discard_samples   = (uint32_t)k_pdm_demo_discard,
    .poll_attempts     = (uint32_t)k_pdm_demo_poll_max,
    .channel           = board_cfg.channel,
    .valid_bits        = board_cfg.valid_bits,
  };
  if (ra8_audio_source_pdm_init(&s_pdm_demo_source, &s_pdm_demo_source_state, &source_cfg) !=
      k_ra8_ok) {
    pdm_demo_tx(k_pdm_demo_banner_fail, (uint32_t)(sizeof(k_pdm_demo_banner_fail) - 1U));
    pdm_demo_panic_halt();
  }
}
 
/* =============================================================================
 * Capture + analysis
 * =============================================================================
 */

static void pdm_demo_analyze(const int32_t* buf, uint32_t n, pdm_metrics_t* m)
{
  if (n == 0U) {
    *m = (pdm_metrics_t){};
    return;
  }
  int64_t sum = 0;
  int32_t lo  = buf[0];
  int32_t hi  = buf[0];
  for (uint32_t i = 0U; i < n; ++i) {
    const int32_t s = buf[i];
    sum += s;
    lo = (s < lo) ? s : lo;
    hi = (s > hi) ? s : hi;
  }
  const int32_t mean = (int32_t)(sum / (int64_t)n);
 
  uint64_t sumsq = 0U;
  int32_t  peak  = 0;
  for (uint32_t i = 0U; i < n; ++i) {
    const int32_t d   = buf[i] - mean;
    const int32_t mag = (d < 0) ? -d : d;
    peak              = (mag > peak) ? mag : peak;
    sumsq += (uint64_t)((int64_t)d * (int64_t)d);
  }
  m->min  = lo;
  m->max  = hi;
  m->mean = mean;
  m->peak = peak;
  m->rms  = (int32_t)pdm_demo_isqrt(sumsq / (uint64_t)n);
  m->n    = n;
}

static bool pdm_demo_is_active(const pdm_metrics_t* m)
{
  const int32_t span = m->max - m->min;
  if (span >= (int32_t)k_pdm_demo_min_span) {
    if (m->rms >= (int32_t)k_pdm_demo_rms_floor) {
      return true;
    }
  }
  return false;
}

static void pdm_demo_publish(const pdm_metrics_t* m, int32_t vary, bool active)
{
  static const uint8_t k_l_rms[]  = "pdm: rms=";
  static const uint8_t k_l_peak[] = " peak=";
  static const uint8_t k_l_mean[] = " mean=";
  static const uint8_t k_l_span[] = " span=";
  static const uint8_t k_l_vary[] = " vary=";
  static const uint8_t k_l_act[]  = " active=";
  static const uint8_t k_l_y[]    = "Y\r\n";
  static const uint8_t k_l_n[]    = "N\r\n";
 
  pdm_demo_emit_kv(k_l_rms, (uint32_t)(sizeof(k_l_rms) - 1U), m->rms);
  pdm_demo_emit_kv(k_l_peak, (uint32_t)(sizeof(k_l_peak) - 1U), m->peak);
  pdm_demo_emit_kv(k_l_mean, (uint32_t)(sizeof(k_l_mean) - 1U), m->mean);
  pdm_demo_emit_kv(k_l_span, (uint32_t)(sizeof(k_l_span) - 1U), m->max - m->min);
  pdm_demo_emit_kv(k_l_vary, (uint32_t)(sizeof(k_l_vary) - 1U), vary);
  pdm_demo_tx(k_l_act, (uint32_t)(sizeof(k_l_act) - 1U));
  if (active) {
    pdm_demo_tx(k_l_y, (uint32_t)(sizeof(k_l_y) - 1U));
  } else {
    pdm_demo_tx(k_l_n, (uint32_t)(sizeof(k_l_n) - 1U));
  }
 
  g_pdm_mic_result.rms     = m->rms;
  g_pdm_mic_result.peak    = m->peak;
  g_pdm_mic_result.mean    = m->mean;
  g_pdm_mic_result.span    = m->max - m->min;
  g_pdm_mic_result.vary    = vary;
  g_pdm_mic_result.samples = m->n;
  g_pdm_mic_result.active  = active ? 1U : 0U;
  g_pdm_mic_result.windows = g_pdm_mic_result.windows + 1U;
  g_pdm_mic_result.magic   = (uint32_t)k_pdm_demo_magic;
}

static bool pdm_demo_run_window(int32_t vary, pdm_metrics_t* out_m)
{
  const ra8_audio_buffer_t buffer = {
    .data     = s_pdm_demo_buf,
    .capacity = (uint32_t)sizeof(s_pdm_demo_buf),
  };
  ra8_audio_frame_t frame = {};
  if (ra8_audio_source_capture(&s_pdm_demo_source, &buffer, &frame) != k_ra8_ok) {
    pdm_demo_tx(k_pdm_demo_banner_nodat, (uint32_t)(sizeof(k_pdm_demo_banner_nodat) - 1U));
    return false;
  }
  pdm_demo_analyze(s_pdm_demo_buf, frame.sample_count, out_m);
  const bool active = pdm_demo_is_active(out_m);
  pdm_demo_publish(out_m, vary, active);
  g_pdm_mic_result.timestamp_ms = frame.timestamp_ms;
  return true;
}
 
/* =============================================================================
 * Main
 * =============================================================================
 */

void main(void)
{
  pdm_demo_clocks_or_halt();
  pdm_demo_io_or_halt();
  pdm_demo_pdm_or_halt();
 
  pdm_metrics_t m = {};
  /* Sweep windows for the verdict, tracking the RMS spread. */
  int32_t  rms_lo         = INT32_MAX;
  int32_t  rms_hi         = 0;
  uint32_t active_windows = 0U;
  for (uint32_t w = 0U; w < (uint32_t)k_pdm_demo_report_win; ++w) {
    const int32_t vary = (rms_hi > rms_lo) ? (rms_hi - rms_lo) : 0;
    if (!pdm_demo_run_window(vary, &m)) {
      pdm_demo_panic_halt();
    }
    rms_lo = (m.rms < rms_lo) ? m.rms : rms_lo;
    rms_hi = (m.rms > rms_hi) ? m.rms : rms_hi;
    active_windows += (g_pdm_mic_result.active != 0U) ? 1U : 0U;
  }
  if (active_windows == 0U) {
    pdm_demo_tx(k_pdm_demo_banner_inactive, (uint32_t)(sizeof(k_pdm_demo_banner_inactive) - 1U));
    pdm_demo_panic_halt();
  }
  pdm_demo_tx(k_pdm_demo_banner_pass, (uint32_t)(sizeof(k_pdm_demo_banner_pass) - 1U));
  while (1) {
    __asm__ volatile("wfi");
  }
 
  pdm_demo_panic_halt();
}