main.c File Reference

#include <assert.h>
#include <math.h>
#include <stdint.h>
#include <stdio.h>
#include "FreeRTOS.h"
#include "esp_adc/adc_cali.h"
#include "esp_adc/adc_cali_scheme.h"
#include "esp_adc/adc_continuous.h"
#include "esp_adc/adc_filter.h"
#include "esp_attr.h"
#include "esp_crc.h"
#include "esp_dsp.h"
#include "esp_err.h"
#include "esp_heap_caps.h"
#include "esp_log.h"
#include "esp_timer.h"
#include "freertos/queue.h"
#include "freertos/semphr.h"
#include "freertos/task.h"
#include "led_strip.h"
#include "string.h"
#include "tinyusb.h"
#include "tusb_cdc_acm.h"

Include dependency graph for main/main.c:

Go to the source code of this file.

Data Structures
struct	frame_wire_t

Macros
#define	OPTIMIZE_O2
#define	FFT_SIZE   CONFIG_ADC_FFT_SIZE
#define	ADC_SPS   CONFIG_ADC_FS
#define	CHANNELS   2
#define	SAMPLE_MAX   4096
#define	LED_STRIP_RMT_RES_HZ   (10 * 1000 * 1000)
#define	SPIKE_DB_THRESHOLD   20.0f
#define	SPIKE_RATIO_THRESHOLD   8.0f
#define	SPIKE_MIN_AVG_LINEAR   1e-7f
#define	FRAME_MAGIC_0   0xF0
#define	FRAME_MAGIC_1   0x0D
#define	FRAME_MAGIC_2   0xF0
#define	FRAME_MAGIC_3   0x0D
#define	FRAME_VERSION   0x02
#define	FRAME_HEADER_SIZE   9u
#define	FRAME_PAYLOAD_SIZE   (sizeof(frame_payload_t))
#define	FRAME_TOTAL_SIZE   (FRAME_HEADER_SIZE + FRAME_PAYLOAD_SIZE + 4u)
#define	CDC_TX_TASK_STACK_SIZE   4096
#define	ADC_TASK_STACK_SIZE   8192

Functions
struct	__attribute__ ((packed))
static void	write_u16_le (uint8_t *dst, uint16_t value)
static void	write_u32_le (uint8_t *dst, uint32_t value)
static void	write_u64_le (uint8_t *dst, uint64_t value)
static uint32_t	frame_crc32 (const uint8_t *data, size_t len)
static void	build_frame (frame_wire_t *out, const float *data, const char label[4], uint64_t t_ms, uint32_t sps, uint16_t seq)
static bool	safe_cdcacm_write_flush (tinyusb_cdcacm_itf_t port, int max_retries)
static void	cdc_tx_task (void *arg)
bool	adc_calibration_init (adc_unit_t unit, adc_atten_t atten)
static float	sample_to_volts (uint16_t raw, bool calibrated)
static float	sample_to_centered (uint16_t raw, bool calibrated, int midpoint_mv)
static void	apply_window (float *buf)
static void	perform_fft (float *buf)
static void	apply_complex_cutoff (float *buf, uint32_t sps)
static adc_atten_t	cfg_atten (void)
static void	adc_fft_task (void *arg)
void	app_main (void)

Variables
static const char *	TAG = "adc_fft"
static float *	ch0 = NULL
static float *	ch1 = NULL
static float *	win = NULL
static adc_cali_handle_t	cali_handle
	frame_payload_t
static QueueHandle_t	g_frameq
static uint16_t	g_seq
static tinyusb_cdcacm_itf_t	g_data_port = TINYUSB_CDC_ACM_0
static TaskHandle_t	g_cdc_task_handle
static TaskHandle_t	g_adc_task_handle

Macro Definition Documentation

ADC_SPS

#define ADC_SPS   CONFIG_ADC_FS

Definition at line 40 of file main/main.c.

Referenced by adc_fft_task().

ADC_TASK_STACK_SIZE

#define ADC_TASK_STACK_SIZE   8192

Definition at line 107 of file main/main.c.

Referenced by app_main().

CDC_TX_TASK_STACK_SIZE

#define CDC_TX_TASK_STACK_SIZE   4096

Definition at line 104 of file main/main.c.

Referenced by app_main().

CHANNELS

#define CHANNELS   2

Definition at line 50 of file main/main.c.

Referenced by adc_fft_task().

FFT_SIZE

#define FFT_SIZE   CONFIG_ADC_FFT_SIZE

Definition at line 39 of file main/main.c.

Referenced by __attribute__(), adc_fft_task(), app_main(), apply_complex_cutoff(), apply_window(), build_frame(), and perform_fft().

FRAME_HEADER_SIZE

#define FRAME_HEADER_SIZE   9u

Definition at line 78 of file main/main.c.

Referenced by build_frame().

FRAME_MAGIC_0

#define FRAME_MAGIC_0   0xF0

Definition at line 73 of file main/main.c.

Referenced by build_frame().

FRAME_MAGIC_1

#define FRAME_MAGIC_1   0x0D

Definition at line 74 of file main/main.c.

Referenced by build_frame().

FRAME_MAGIC_2

#define FRAME_MAGIC_2   0xF0

Definition at line 75 of file main/main.c.

Referenced by build_frame().

FRAME_MAGIC_3

#define FRAME_MAGIC_3   0x0D

Definition at line 76 of file main/main.c.

Referenced by build_frame().

FRAME_PAYLOAD_SIZE

#define FRAME_PAYLOAD_SIZE   (sizeof(frame_payload_t))

Definition at line 79 of file main/main.c.

Referenced by build_frame().

FRAME_TOTAL_SIZE

#define FRAME_TOTAL_SIZE   (FRAME_HEADER_SIZE + FRAME_PAYLOAD_SIZE + 4u)

Definition at line 80 of file main/main.c.

#define FRAME_TOTAL_SIZE                                                       \
  (FRAME_HEADER_SIZE + FRAME_PAYLOAD_SIZE + 4u) // +4 for CRC32

Referenced by cdc_tx_task().

FRAME_VERSION

#define FRAME_VERSION   0x02

Definition at line 77 of file main/main.c.

Referenced by build_frame().

LED_STRIP_RMT_RES_HZ

#define LED_STRIP_RMT_RES_HZ   (10 * 1000 * 1000)

Definition at line 53 of file main/main.c.

OPTIMIZE_O2

#define OPTIMIZE_O2

Definition at line 36 of file main/main.c.

Referenced by apply_complex_cutoff(), apply_window(), and perform_fft().

SAMPLE_MAX

#define SAMPLE_MAX   4096

Definition at line 51 of file main/main.c.

SPIKE_DB_THRESHOLD

#define SPIKE_DB_THRESHOLD   20.0f

Definition at line 55 of file main/main.c.

SPIKE_MIN_AVG_LINEAR

#define SPIKE_MIN_AVG_LINEAR   1e-7f

Definition at line 57 of file main/main.c.

SPIKE_RATIO_THRESHOLD

#define SPIKE_RATIO_THRESHOLD   8.0f

Definition at line 56 of file main/main.c.

Function Documentation

__attribute__()

struct __attribute__

(

(packed)

)

Definition at line 63 of file main/main.c.

                                       {
  uint64_t t_ms;
  uint32_t sps;
  uint32_t fft;
  char label[4];
  float data[FFT_SIZE];
} frame_payload_t;

References __attribute__(), cali_handle, data, and FFT_SIZE.

Referenced by __attribute__().

Here is the call graph for this function:

Here is the caller graph for this function:

adc_calibration_init()

bool adc_calibration_init	(	adc_unit_t	unit,
		adc_atten_t	atten )

Definition at line 411 of file main/main.c.

                                                              {
  adc_cali_curve_fitting_config_t cali_config = {
      .unit_id = unit,
      .atten = atten,
      .bitwidth = ADC_BITWIDTH_12,
  };
  if (adc_cali_create_scheme_curve_fitting(&cali_config, &cali_handle) ==
      ESP_OK) {
    ESP_LOGI(TAG, "ADC calibration ready (curve fitting)");
    return true;
  }
  ESP_LOGW(TAG, "ADC calibration not available; raw counts will be used");
  return false;
}

References cali_handle, ESP_OK, and TAG.

Referenced by adc_fft_task().

Here is the caller graph for this function:

adc_fft_task()

void adc_fft_task ( void * arg )

static

Definition at line 488 of file main/main.c.

                                    {
  adc_atten_t atten = cfg_atten();
  bool calibrated = adc_calibration_init(ADC_UNIT_1, atten);
  int midpoint_mv = 0;
  if (calibrated) {
    (void)adc_cali_raw_to_voltage(cali_handle, 2048, &midpoint_mv);
  }
 
  /* ADC decode diagnostics: validates that DMA words are parsed as expected
   * (unit/channel/bitwidth). If ADC output format mismatches parsing, these
   * counters will look obviously wrong (e.g., few accepted samples, many
   * skipped/other channels).
   */
  uint64_t last_adc_diag_ms = esp_timer_get_time() / 1000ULL;
  uint32_t diag_reads = 0;
  uint32_t diag_out_bytes = 0;
  uint32_t diag_accept_ch0 = 0;
  uint32_t diag_accept_ch1 = 0;
  uint32_t diag_skip_unit = 0;
  uint32_t diag_other_chan = 0;
 
  adc_continuous_handle_t adc_handle = NULL;
  adc_continuous_handle_cfg_t handle_cfg = {
      .max_store_buf_size =
          FFT_SIZE * CHANNELS * sizeof(adc_digi_output_data_t),
      .conv_frame_size = 512,
  };
  ESP_ERROR_CHECK(adc_continuous_new_handle(&handle_cfg, &adc_handle));
 
  uint32_t sample_rate = ADC_SPS;
#if defined(CONFIG_SOC_ADC_SAMPLE_FREQ_THRES_HIGH)
  if (sample_rate > CONFIG_SOC_ADC_SAMPLE_FREQ_THRES_HIGH) {
    ESP_LOGW(TAG, "ADC_SPS=%u above SOC max %u; clamping", sample_rate,
             (unsigned)CONFIG_SOC_ADC_SAMPLE_FREQ_THRES_HIGH);
    sample_rate = CONFIG_SOC_ADC_SAMPLE_FREQ_THRES_HIGH;
  }
#endif
#if defined(CONFIG_SOC_ADC_SAMPLE_FREQ_THRES_LOW)
  if (sample_rate < CONFIG_SOC_ADC_SAMPLE_FREQ_THRES_LOW) {
    ESP_LOGW(TAG, "ADC_SPS=%u below SOC min %u; clamping", sample_rate,
             (unsigned)CONFIG_SOC_ADC_SAMPLE_FREQ_THRES_LOW);
    sample_rate = CONFIG_SOC_ADC_SAMPLE_FREQ_THRES_LOW;
  }
#endif
 
  /* Per-channel sampling rate: adc_continuous divides sample_freq_hz by the
   * pattern length. With two channels, each gets half the configured rate. */
  const uint32_t per_channel_sps = sample_rate / CHANNELS;
 
  adc_digi_pattern_config_t pattern[CHANNELS] = {0};
  pattern[0].atten = atten;
  pattern[0].channel = CONFIG_ADC_CH0;
  pattern[0].unit = ADC_UNIT_1;
  pattern[0].bit_width = ADC_BITWIDTH_12;
  pattern[1].atten = atten;
  pattern[1].channel = CONFIG_ADC_CH1;
  pattern[1].unit = ADC_UNIT_1;
  pattern[1].bit_width = ADC_BITWIDTH_12;
 
  adc_continuous_config_t dig_cfg = {
      .sample_freq_hz = sample_rate,
      .conv_mode = ADC_CONV_SINGLE_UNIT_1,
      /* Must match adc_digi_output_data_t parsing below (p->type2.*). */
      .format = ADC_DIGI_OUTPUT_FORMAT_TYPE2,
      .pattern_num = CHANNELS,
      .adc_pattern = pattern,
  };
  ESP_ERROR_CHECK(adc_continuous_config(adc_handle, &dig_cfg));
 
#if CONFIG_ADC_IIR_FILTER_ENABLE
  adc_digi_iir_filter_t coeff = ADC_DIGI_IIR_FILTER_COEFF_2;
#if CONFIG_ADC_IIR_FILTER_COEFF_4
  coeff = ADC_DIGI_IIR_FILTER_COEFF_4;
#elif CONFIG_ADC_IIR_FILTER_COEFF_8
  coeff = ADC_DIGI_IIR_FILTER_COEFF_8;
#elif CONFIG_ADC_IIR_FILTER_COEFF_16
  coeff = ADC_DIGI_IIR_FILTER_COEFF_16;
#elif CONFIG_ADC_IIR_FILTER_COEFF_64
  coeff = ADC_DIGI_IIR_FILTER_COEFF_64;
#endif
  adc_continuous_iir_filter_config_t filter_cfg = {
      .unit = ADC_UNIT_1,
      .coeff = coeff,
  };
  adc_iir_filter_handle_t iir_handle = NULL;
  ESP_ERROR_CHECK(
      adc_new_continuous_iir_filter(adc_handle, &filter_cfg, &iir_handle));
  ESP_ERROR_CHECK(adc_continuous_iir_filter_enable(iir_handle));
  ESP_LOGI(TAG, "ADC IIR Filter enabled");
#endif
 
  ESP_ERROR_CHECK(adc_continuous_start(adc_handle));
 
  ESP_LOGI(TAG,
           "Sampling ADC1 CH%d (GPIO%d) and CH%d (GPIO%d) at %u sps/ch, FFT %d",
           CONFIG_ADC_CH0, CONFIG_ADC_CH0 + 1, CONFIG_ADC_CH1,
           CONFIG_ADC_CH1 + 1, (unsigned)per_channel_sps, FFT_SIZE);
 
  // Reduce DMA buffer size to save Internal RAM; we loop to fill the FFT buffer anyway.
  const size_t read_len = 2048 * sizeof(adc_digi_output_data_t); 
  uint8_t *raw = heap_caps_aligned_alloc(16, read_len,
                                         MALLOC_CAP_DMA | MALLOC_CAP_INTERNAL);
  if (!raw) {
    raw = heap_caps_aligned_alloc(16, read_len, MALLOC_CAP_DMA);
  }
  if (!raw) {
    ESP_LOGE(TAG, "Failed to reserve DMA buffer (%zu bytes)", read_len);
    vTaskDelete(NULL);
    return;
  }
 
  static frame_wire_t frame;
  while (1) { 
#if CONFIG_STATUS_NEOPIXEL_ENABLE
    status_led_set(0, 0, 255);
#endif
    int count0 = 0;
    int count1 = 0;
    float sum0 = 0.0f;
    float sum1 = 0.0f;
    while (count0 < FFT_SIZE || count1 < FFT_SIZE) {
      uint32_t out_len = 0;
      esp_err_t ret = adc_continuous_read(adc_handle, raw, read_len, &out_len,
                                          pdMS_TO_TICKS(100));
      if (ret == ESP_ERR_TIMEOUT) {
        continue;
      }
      if (ret != ESP_OK) {
        ESP_LOGW(TAG, "adc_continuous_read returned %s", esp_err_to_name(ret));
        vTaskDelay(pdMS_TO_TICKS(1));
        continue;
      }
 
      /* Per-read diagnostics. */
      diag_reads++;
      diag_out_bytes += out_len;
 
      for (uint32_t i = 0; i + sizeof(adc_digi_output_data_t) <= out_len;
           i += sizeof(adc_digi_output_data_t)) {
        adc_digi_output_data_t *p = (adc_digi_output_data_t *)&raw[i];
        if (p->type2.unit != ADC_UNIT_1) {
          diag_skip_unit++;
          continue;
        }
        if (p->type2.channel == CONFIG_ADC_CH0 && count0 < FFT_SIZE) {
          float val = sample_to_centered(p->type2.data, calibrated, midpoint_mv);
          ch0[count0++] = val;
          sum0 += val;
          diag_accept_ch0++;
        } else if (p->type2.channel == CONFIG_ADC_CH1 && count1 < FFT_SIZE) {
          float val = sample_to_centered(p->type2.data, calibrated, midpoint_mv);
          ch1[count1++] = val;
          sum1 += val;
          diag_accept_ch1++;
        } else {
          diag_other_chan++;
        }
      }
 
      /* Rate-limit to avoid log spam. */
      uint64_t now_ms = esp_timer_get_time() / 1000ULL;
      if (now_ms > last_adc_diag_ms + 2000ULL) {
        ESP_LOGI(TAG,
                 "ADC diag (2s): reads=%u out=%uB accept[ch0/ch1]=%u/%u skip_unit=%u other_chan=%u",
                 (unsigned)diag_reads, (unsigned)diag_out_bytes,
                 (unsigned)diag_accept_ch0, (unsigned)diag_accept_ch1,
                 (unsigned)diag_skip_unit, (unsigned)diag_other_chan);
        diag_reads = 0;
        diag_out_bytes = 0;
        diag_accept_ch0 = 0;
        diag_accept_ch1 = 0;
        diag_skip_unit = 0;
        diag_other_chan = 0;
        last_adc_diag_ms = now_ms;
      }
    }
 
    /* Dynamic DC bias removal: subtract current block mean */
    float mean0 = (float)(sum0 / FFT_SIZE);
    float mean1 = (float)(sum1 / FFT_SIZE);
    for (int i = 0; i < FFT_SIZE; i++) {
      ch0[i] -= mean0;
      ch1[i] -= mean1;
    }
 
#if CONFIG_ADC_ENABLE_WINDOW
    apply_window(ch0);
    apply_window(ch1);
#endif
    perform_fft(ch0);
    perform_fft(ch1);
 
   // apply_complex_cutoff(ch0, per_channel_sps);
   // apply_complex_cutoff(ch1, per_channel_sps);
 
    uint64_t now_ms = esp_timer_get_time() / 1000ULL;
 
    build_frame(&frame, ch0, "ch0", now_ms, per_channel_sps, g_seq++);
    if (xQueueSend(g_frameq, &frame, portMAX_DELAY) != pdTRUE) {
      ESP_LOGW(TAG, "Frame queue send failed (ch0)");
    }
 
    build_frame(&frame, ch1, "ch1", now_ms, per_channel_sps, g_seq++);
    if (xQueueSend(g_frameq, &frame, portMAX_DELAY) != pdTRUE) {
      ESP_LOGW(TAG, "Frame queue send failed (ch1)");
    }
  }
}

References adc_calibration_init(), ADC_SPS, apply_window(), build_frame(), cali_handle, cfg_atten(), ch0, ch1, CHANNELS, ESP_OK, FFT_SIZE, g_frameq, g_seq, perform_fft(), sample_to_centered(), and TAG.

Referenced by app_main().

Here is the call graph for this function:

Here is the caller graph for this function:

app_main()

void app_main

(

void

)

Definition at line 720 of file main/main.c.

                    {
#if CONFIG_STATUS_NEOPIXEL_ENABLE
  status_led_init();
  status_led_set(255, 0, 0);
#endif
  tinyusb_config_t tusb_cfg = {
      .device_descriptor = NULL,
      .string_descriptor = NULL,
      .external_phy = false,
  };
  ESP_ERROR_CHECK(tinyusb_driver_install(&tusb_cfg));
 
#if CONFIG_TINYUSB_CDC_COUNT > 1
  g_data_port = TINYUSB_CDC_ACM_1;
#else
  g_data_port = TINYUSB_CDC_ACM_0;
#endif
 
  tinyusb_config_cdcacm_t cdc_cfg_data = {
      .usb_dev = TINYUSB_USBDEV_0,
      .cdc_port = g_data_port,
      .rx_unread_buf_sz = CONFIG_TINYUSB_CDC_RX_BUFSIZE,
      .callback_rx = NULL,
      .callback_rx_wanted_char = NULL,
      .callback_line_state_changed = NULL,
      .callback_line_coding_changed = NULL,
  };
  ESP_ERROR_CHECK(tusb_cdc_acm_init(&cdc_cfg_data));
 
 
#if CONFIG_ENABLE_I2S_WAVE_GEN
  // Initialize Wave Gen
  // Using GPIO 15-18 to avoid VDD_SPI (GPIO 11) and ADC1 interference
  wave_gen_config_t wg_cfg = {
      .mck_io_num = -1, // SCK disconnected (PCM5102 internal generation)
      .bck_io_num = 16,
      .ws_io_num = 17,
      .data_out_num = 18,
      .sample_rate = 44100,
  };
  ESP_ERROR_CHECK(wave_gen_init(&wg_cfg));
  // wave_gen_set_freq(33.0f); // Controlled by sweep_task
  wave_gen_set_type(WAVE_TYPE_SINE);
  wave_gen_set_volume(0.5f);
  ESP_ERROR_CHECK(wave_gen_start());
#endif
 
#if CONFIG_ENABLE_SDM_WAVE_GEN
  ESP_ERROR_CHECK(wave_gen_sdm_start());
#endif
 
  size_t fft_mem_sz = FFT_SIZE * sizeof(float);
  ch0 = heap_caps_aligned_alloc(16, fft_mem_sz, MALLOC_CAP_SPIRAM);
  ch1 = heap_caps_aligned_alloc(16, fft_mem_sz, MALLOC_CAP_SPIRAM);
  win = heap_caps_aligned_alloc(16, fft_mem_sz, MALLOC_CAP_SPIRAM);
  
  if (!ch0 || !ch1 || !win) {
      ESP_LOGE(TAG, "Failed to allocate FFT buffers");
      abort();
  }
 
  /* Initialize DSP before any task can call FFT/window code. */
  ESP_ERROR_CHECK(dsps_fft4r_init_fc32(NULL, FFT_SIZE >> 1));
#if CONFIG_ADC_ENABLE_WINDOW
#if CONFIG_ADC_WINDOW_HANN
  dsps_wind_hann_f32(win, FFT_SIZE);
#elif CONFIG_ADC_WINDOW_BLACKMAN
  dsps_wind_blackman_f32(win, FFT_SIZE);
#elif CONFIG_ADC_WINDOW_BLACKMAN_HARRIS
  dsps_wind_blackman_harris_f32(win, FFT_SIZE);
#elif CONFIG_ADC_WINDOW_BLACKMAN_NUTTALL
  dsps_wind_blackman_nuttall_f32(win, FFT_SIZE);
#elif CONFIG_ADC_WINDOW_NUTTALL
  dsps_wind_nuttall_f32(win, FFT_SIZE);
#elif CONFIG_ADC_WINDOW_FLAT_TOP
  dsps_wind_flat_top_f32(win, FFT_SIZE);
#else
  for (int i = 0; i < FFT_SIZE; i++) {
    win[i] = 1.0f;
  }
#endif
#endif
 
 
#if CONFIG_ENABLE_I2S_WAVE_GEN
  xTaskCreate(sweep_task, "sweep", 2048, NULL, 5, NULL);
#endif
 
  g_frameq = xQueueCreate(
                          2,
                          sizeof(frame_wire_t));
  assert(g_frameq);
 
  const BaseType_t tusb_core = 0;
#if CONFIG_FREERTOS_UNICORE
  const BaseType_t adc_core = 0;
#else
  const BaseType_t adc_core = 1;
#endif
 
  xTaskCreatePinnedToCore(
                          cdc_tx_task,
                          "cdc_tx",
                          CDC_TX_TASK_STACK_SIZE,
                          NULL,
                          8,
                          &g_cdc_task_handle,
                          tusb_core);
 
 
 
                          
  xTaskCreatePinnedToCore(
  adc_fft_task,
  "adc_fft",
  ADC_TASK_STACK_SIZE,
  NULL,
  8,
  &g_adc_task_handle,
  adc_core);
 
  xTaskCreatePinnedToCore(
                         adc_fft_task,
                         "adc_fft",
                         ADC_TASK_STACK_SIZE,
                         NULL,
                         8,
                         &g_adc_task_handle,
                         adc_core
                        );
 
  xTaskCreatePinnedToCore(adc_fft_task,"adc_fft",ADC_TASK_STACK_SIZE,NULL,8,&g_adc_task_handle,adc_core);
 
 
  // Tasks run indefinitely; app_main can return.
}

References adc_fft_task(), ADC_TASK_STACK_SIZE, cdc_tx_task(), CDC_TX_TASK_STACK_SIZE, ch0, ch1, dsps_fft4r_init_fc32(), dsps_wind_blackman_f32(), dsps_wind_blackman_harris_f32(), dsps_wind_blackman_nuttall_f32(), dsps_wind_flat_top_f32(), dsps_wind_hann_f32(), dsps_wind_nuttall_f32(), FFT_SIZE, g_adc_task_handle, g_cdc_task_handle, g_data_port, g_frameq, TAG, TINYUSB_CDC_ACM_0, TINYUSB_CDC_ACM_1, tinyusb_driver_install(), TINYUSB_USBDEV_0, tusb_cdc_acm_init(), wave_gen_init(), wave_gen_sdm_start(), wave_gen_set_type(), wave_gen_set_volume(), wave_gen_start(), WAVE_TYPE_SINE, and win.

Here is the call graph for this function:

apply_complex_cutoff()

void apply_complex_cutoff ( float * buf, uint32_t sps )

static

Definition at line 459 of file main/main.c.

                                                                       {
#if CONFIG_OUTPUT_CUTOFF_HZ > 0
  uint32_t cutoff_hz = (uint32_t)CONFIG_OUTPUT_CUTOFF_HZ;
  uint32_t max_bin = (cutoff_hz * (uint64_t)FFT_SIZE) / sps;
  if (max_bin >= FFT_SIZE / 2) {
    return;
  }
  if (max_bin < FFT_SIZE / 2) {
    buf[1] = 0.0f; // Nyquist packed at index 1
  }
  for (uint32_t k = max_bin + 1; k < FFT_SIZE / 2; k++) {
    buf[2 * k] = 0.0f;
    buf[2 * k + 1] = 0.0f;
  }
#endif
}

References FFT_SIZE, k, and OPTIMIZE_O2.

apply_window()

void apply_window ( float * buf )

static

Definition at line 447 of file main/main.c.

                                                 {
  for (int i = 0; i < FFT_SIZE; i++) {
    buf[i] *= win[i];
  }
}

References FFT_SIZE, OPTIMIZE_O2, and win.

Referenced by adc_fft_task().

Here is the caller graph for this function:

build_frame()

void build_frame ( frame_wire_t * out, const float * data, const char label[4], uint64_t t_ms, uint32_t sps, uint16_t seq )

static

Definition at line 130 of file main/main.c.

                                      {
  uint8_t *dst = out->bytes;
  dst[0] = FRAME_MAGIC_0;
  dst[1] = FRAME_MAGIC_1;
  dst[2] = FRAME_MAGIC_2;
  dst[3] = FRAME_MAGIC_3;
  dst[4] = FRAME_VERSION;
  write_u16_le(dst + 5, seq);
  write_u16_le(dst + 7, (uint16_t)FRAME_PAYLOAD_SIZE);
 
  size_t off = FRAME_HEADER_SIZE;
  write_u64_le(dst + off, t_ms);
  off += sizeof(uint64_t);
  write_u32_le(dst + off, sps);
  off += sizeof(uint32_t);
  write_u32_le(dst + off, FFT_SIZE);
  off += sizeof(uint32_t);
  memcpy(dst + off, label, 4);
  off += 4;
  memcpy(dst + off, data, sizeof(float) * FFT_SIZE);
  off += sizeof(float) * FFT_SIZE;
 
  uint32_t crc = frame_crc32(dst, FRAME_HEADER_SIZE + FRAME_PAYLOAD_SIZE);
  write_u32_le(dst + off, crc);
}

References frame_wire_t::bytes, data, FFT_SIZE, frame_crc32(), FRAME_HEADER_SIZE, FRAME_MAGIC_0, FRAME_MAGIC_1, FRAME_MAGIC_2, FRAME_MAGIC_3, FRAME_PAYLOAD_SIZE, FRAME_VERSION, write_u16_le(), write_u32_le(), and write_u64_le().

Referenced by adc_fft_task().

Here is the call graph for this function:

Here is the caller graph for this function:

cdc_tx_task()

void cdc_tx_task ( void * arg )

static

Definition at line 254 of file main/main.c.

                                   {
#if 1
  static frame_wire_t frm;
 
  const size_t max_chunk = 512;
  const uint32_t wait_step_ms = 2;
  /* Increase timeout significantly for large FFT sizes to prevent frame drops
   * that cause stream desynchronization. For FFT=4096, frame interval is ~100ms;
   * allow up to 10 seconds for host processing/backpressure.
   */
  const uint32_t wait_budget_ms = 10000;
 
  
#if CONFIG_DIAG_CDC_ENABLE
  /* initialize diagnostic window at task start */
  diag_cdc_reset_window(esp_timer_get_time() / 1000ULL);
  uint64_t last_stack_log_ms = esp_timer_get_time() / 1000ULL;
#endif
  while (1) {
    if (xQueueReceive(g_frameq, &frm, portMAX_DELAY) == pdTRUE) {
      if (!tusb_cdc_acm_initialized(g_data_port) ||
          !tud_cdc_n_connected((uint8_t)g_data_port)) {
        /* Host not connected: sleep longer to avoid starving idle/other tasks
         */
        vTaskDelay(pdMS_TO_TICKS(100));
        continue;
      }
 
      /* Send in bounded chunks, waiting briefly for space if needed. */
      size_t sent = 0;
      uint32_t waited_ms = 0;
      while (sent < FRAME_TOTAL_SIZE) {
        if (!tud_cdc_n_connected((uint8_t)g_data_port)) {
          break;
        }
 
        size_t chunk = FRAME_TOTAL_SIZE - sent;
        if (chunk > max_chunk) {
          chunk = max_chunk;
        }
 
        uint32_t wa = tud_cdc_n_write_available((uint8_t)g_data_port);
#if CONFIG_DIAG_CDC_ENABLE && CONFIG_DIAG_CDC_SAMPLE_WRITE_AVAILABLE
        diag_cdc_sample_wa(wa);
#endif
        if (wa < chunk) {
          if (waited_ms >= wait_budget_ms) {
            ESP_LOGW(TAG, "CDC TX backpressure (%u ms), dropping frame",
                     (unsigned)waited_ms);
            break;
          }
          vTaskDelay(pdMS_TO_TICKS(wait_step_ms));
          waited_ms += wait_step_ms;
          continue;
        }
 
        size_t queued =
            tinyusb_cdcacm_write_queue(g_data_port, frm.bytes + sent, chunk);
        if (queued == 0) {
          if (waited_ms >= wait_budget_ms) {
            ESP_LOGW(TAG, "CDC TX stalled (%u ms), dropping frame",
                     (unsigned)waited_ms);
            break;
          }
          vTaskDelay(pdMS_TO_TICKS(wait_step_ms));
          waited_ms += wait_step_ms;
          continue;
        }
#if CONFIG_DIAG_CDC_ENABLE
        diag_cdc_on_queued(queued);
#endif
        sent += queued;
      }
 
      if (sent < FRAME_TOTAL_SIZE) {
        ESP_LOGW(TAG, "CDC send dropped %u bytes",
                 (unsigned)(FRAME_TOTAL_SIZE - sent));
#if CONFIG_DIAG_CDC_ENABLE
        /* Report diagnostics even when a frame is dropped. */
        uint64_t now_ms = esp_timer_get_time() / 1000ULL;
        diag_cdc_maybe_log(now_ms);
#endif
        continue;
      }
 
      if (!safe_cdcacm_write_flush(g_data_port, 6)) {
        ESP_LOGD(TAG, "CDC flush timeout (non-fatal)");
      }
#if CONFIG_STATUS_NEOPIXEL_ENABLE
      if (g_led_strip) {
        if (!g_led_lock ||
            xSemaphoreTake(g_led_lock, pdMS_TO_TICKS(10)) == pdTRUE) {
          uint8_t b = (uint8_t)CONFIG_STATUS_NEOPIXEL_BRIGHTNESS;
          ESP_ERROR_CHECK(led_strip_set_pixel(g_led_strip, 0, 0, b, 0));
          ESP_ERROR_CHECK(led_strip_refresh(g_led_strip));
          if (g_led_lock) {
            xSemaphoreGive(g_led_lock);
          }
        }
      }
#endif
#if CONFIG_DIAG_CDC_ENABLE
      /* periodic summary log (non-blocking) */
      uint64_t now_ms = esp_timer_get_time() / 1000ULL;
      diag_cdc_maybe_log(now_ms);
 
      if (now_ms > last_stack_log_ms + 5000ULL) {
        UBaseType_t cdc_hwm = uxTaskGetStackHighWaterMark(g_cdc_task_handle);
        UBaseType_t adc_hwm = uxTaskGetStackHighWaterMark(g_adc_task_handle);
        ESP_LOGI(TAG, "Stack HWM: cdc_tx=%lu words, adc_fft=%lu words",
                 (unsigned long)cdc_hwm, (unsigned long)adc_hwm);
        last_stack_log_ms = now_ms;
      }
#endif
    }
  }
}

References frame_wire_t::bytes, ESP_LOGD, FRAME_TOTAL_SIZE, g_adc_task_handle, g_cdc_task_handle, g_data_port, g_frameq, led_strip_refresh(), led_strip_set_pixel(), safe_cdcacm_write_flush(), TAG, tinyusb_cdcacm_write_queue(), and tusb_cdc_acm_initialized().

Referenced by app_main().

Here is the call graph for this function:

Here is the caller graph for this function:

cfg_atten()

adc_atten_t cfg_atten ( void )

static

Definition at line 476 of file main/main.c.

                                   {
#if CONFIG_ADC_ATTEN_DB_0
  return ADC_ATTEN_DB_0;
#elif CONFIG_ADC_ATTEN_DB_2_5
  return ADC_ATTEN_DB_2_5;
#elif CONFIG_ADC_ATTEN_DB_6
  return ADC_ATTEN_DB_6;
#else
  return ADC_ATTEN_DB_12;
#endif
}

Referenced by adc_fft_task().

Here is the caller graph for this function:

frame_crc32()

uint32_t frame_crc32 ( const uint8_t * data, size_t len )

static

Definition at line 126 of file main/main.c.

                                                             {
  return esp_crc32_le(0, data, len);
}

References data.

Referenced by build_frame().

Here is the caller graph for this function:

perform_fft()

void perform_fft ( float * buf )

static

Definition at line 453 of file main/main.c.

                                                {
  dsps_fft4r_fc32(buf, FFT_SIZE >> 1);
  dsps_bit_rev4r_fc32(buf, FFT_SIZE >> 1);
  dsps_cplx2real_fc32(buf, FFT_SIZE >> 1);
}

References dsps_bit_rev4r_fc32, dsps_cplx2real_fc32, dsps_fft4r_fc32, FFT_SIZE, and OPTIMIZE_O2.

Referenced by adc_fft_task().

Here is the caller graph for this function:

safe_cdcacm_write_flush()

bool safe_cdcacm_write_flush ( tinyusb_cdcacm_itf_t port, int max_retries )

static

Definition at line 221 of file main/main.c.

{
  if (!tud_cdc_n_connected((uint8_t)port)) {
    return false;
  }
 
  const int base_delay_ms = 100;
  uint64_t now_ms = 0;
  static uint64_t last_flush_log_ms = 0;
 
  for (int attempt = 0; attempt < max_retries; ++attempt) {
    /* Increase flush timeout to 1000ms to allow large buffers (32KB) to drain
     * at minimum USB speeds (335KB/s -> ~96ms), with margin for host latency.
     */
    esp_err_t err = tinyusb_cdcacm_write_flush(port, 1000);
    if (err == ESP_OK) {
      return true;
    }
    if (!tud_cdc_n_connected((uint8_t)port)) {
      return false;
    }
    vTaskDelay(pdMS_TO_TICKS(base_delay_ms << attempt));
  }
 
  /* Rate-limit the warning to once per second to avoid spam. */
  now_ms = esp_timer_get_time() / 1000ULL;
  if (now_ms > last_flush_log_ms + 1000ULL) {
    ESP_LOGW(TAG, "CDC flush failed after %d retries", max_retries);
    last_flush_log_ms = now_ms;
  }
  return false;
}

References ESP_OK, TAG, and tinyusb_cdcacm_write_flush().

Referenced by cdc_tx_task().

Here is the call graph for this function:

Here is the caller graph for this function:

sample_to_centered()

float sample_to_centered ( uint16_t raw, bool calibrated, int midpoint_mv )

inlinestatic

Definition at line 436 of file main/main.c.

                                                        {
  if (calibrated) {
    int mv = 0;
    if (adc_cali_raw_to_voltage(cali_handle, raw, &mv) == ESP_OK) {
      return ((float)(mv - midpoint_mv)) / 1000.0f;
    }
  }
  return (float)raw - 2048.0f; // 12-bit midpoint
}

References cali_handle, and ESP_OK.

Referenced by adc_fft_task().

Here is the caller graph for this function:

sample_to_volts()

float sample_to_volts ( uint16_t raw, bool calibrated )

inlinestatic

Definition at line 426 of file main/main.c.

                                                                   {
  if (calibrated) {
    int mv = 0;
    if (adc_cali_raw_to_voltage(cali_handle, raw, &mv) == ESP_OK) {
      return (float)mv / 1000.0f;
    }
  }
  return (float)raw; // fallback raw counts
}

References cali_handle, and ESP_OK.

write_u16_le()

void write_u16_le ( uint8_t * dst, uint16_t value )

inlinestatic

Definition at line 109 of file main/main.c.

                                                              {
  dst[0] = (uint8_t)(value & 0xFFu);
  dst[1] = (uint8_t)((value >> 8) & 0xFFu);
}

Referenced by build_frame().

Here is the caller graph for this function:

write_u32_le()

void write_u32_le ( uint8_t * dst, uint32_t value )

inlinestatic

Definition at line 114 of file main/main.c.

                                                              {
  dst[0] = (uint8_t)(value & 0xFFu);
  dst[1] = (uint8_t)((value >> 8) & 0xFFu);
  dst[2] = (uint8_t)((value >> 16) & 0xFFu);
  dst[3] = (uint8_t)((value >> 24) & 0xFFu);
}

Referenced by build_frame(), and write_u64_le().

Here is the caller graph for this function:

write_u64_le()

void write_u64_le ( uint8_t * dst, uint64_t value )

inlinestatic

Definition at line 121 of file main/main.c.

                                                              {
  write_u32_le(dst, (uint32_t)(value & 0xFFFFFFFFu));
  write_u32_le(dst + 4, (uint32_t)((value >> 32) & 0xFFFFFFFFu));
}

References write_u32_le().

Referenced by build_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

cali_handle

adc_cali_handle_t cali_handle

static

Definition at line 63 of file main/main.c.

Referenced by __attribute__(), adc_calibration_init(), adc_fft_task(), sample_to_centered(), and sample_to_volts().

ch0

float* ch0 = NULL

static

Definition at line 59 of file main/main.c.

Referenced by adc_fft_task(), and app_main().

ch1

float* ch1 = NULL

static

Definition at line 60 of file main/main.c.

Referenced by adc_fft_task(), and app_main().

frame_payload_t

frame_payload_t

Definition at line 71 of file main/main.c.

g_adc_task_handle

TaskHandle_t g_adc_task_handle

static

Definition at line 95 of file main/main.c.

Referenced by app_main(), and cdc_tx_task().

g_cdc_task_handle

TaskHandle_t g_cdc_task_handle

static

Definition at line 94 of file main/main.c.

Referenced by app_main(), and cdc_tx_task().

g_data_port

tinyusb_cdcacm_itf_t g_data_port = TINYUSB_CDC_ACM_0

static

Definition at line 93 of file main/main.c.

Referenced by app_main(), and cdc_tx_task().

g_frameq

QueueHandle_t g_frameq

static

Definition at line 91 of file main/main.c.

Referenced by adc_fft_task(), app_main(), and cdc_tx_task().

g_seq

uint16_t g_seq

static

Definition at line 92 of file main/main.c.

Referenced by adc_fft_task().

TAG

const char* TAG = "adc_fft"

static

Definition at line 31 of file main/main.c.

Referenced by adc_calibration_init(), adc_fft_task(), app_init(), app_init(), app_main(), app_main(), apply_path(), audio_process_task(), audio_process_task(), audio_process_task(), audio_read_task(), audio_read_task(), audio_read_task(), bsp_spi_init(), bsp_spi_init(), buttons_process_task(), buttons_process_task(), buttons_process_task(), cdc_obj_check(), cdc_tx_task(), dsp_display_brightness_init(), dsp_display_brightness_init(), dsp_display_new(), dsps_ccorr_f32_ansi(), dsps_conv_f32_ansi(), dsps_cplx_gen_freq_get(), dsps_cplx_gen_freq_set(), dsps_cplx_gen_init(), dsps_cplx_gen_phase_get(), dsps_cplx_gen_phase_set(), dsps_cplx_gen_set(), dsps_gen_bitrev2r_table(), dsps_gen_bitrev4r_table(), dsps_sfdr_f32(), dsps_snr_f32(), esp_tusb_deinit_console(), esp_tusb_init_console(), esp_vfs_tusb_cdc_register(), esp_vfs_tusb_cdc_unregister(), init_3d_matrix_struct(), init_3d_matrix_struct(), led_strip_clear(), led_strip_del(), led_strip_new_rmt_device(), led_strip_new_rmt_device(), led_strip_new_spi_device(), led_strip_refresh(), led_strip_rmt_del(), led_strip_rmt_del(), led_strip_rmt_refresh(), led_strip_rmt_refresh(), led_strip_rmt_set_pixel(), led_strip_rmt_set_pixel(), led_strip_rmt_set_pixel_rgbw(), led_strip_set_pixel(), led_strip_set_pixel_hsv(), led_strip_set_pixel_rgbw(), led_strip_spi_del(), led_strip_spi_refresh(), led_strip_spi_set_pixel(), led_strip_spi_set_pixel_rgbw(), microphone_read_task(), microphone_read_task(), redirect_std_streams_to(), restore_std_streams(), ringbuf_mux_take(), rmt_new_led_strip_encoder(), safe_cdcacm_write_flush(), tinyusb_cdc_deinit(), tinyusb_cdc_init(), tinyusb_cdcacm_read(), tinyusb_cdcacm_register_callback(), tinyusb_cdcacm_unregister_callback(), tinyusb_cdcacm_write_flush(), tinyusb_driver_install(), tud_cdc_line_state_cb(), tud_cdc_rx_cb(), tud_descriptor_string_cb(), tusb_cdc_acm_init(), tusb_cdc_comm_init(), tusb_cdc_data_init(), tusb_cdc_deinit_comm(), tusb_cdc_deinit_data(), tusb_device_task(), tusb_run_task(), tusb_set_descriptor(), tusb_stop_task(), wave_gen_init(), wave_gen_sdm_start(), wave_gen_start(), wave_gen_stop(), and wave_gen_task().

win

float* win = NULL

static

Definition at line 61 of file main/main.c.

Referenced by app_main(), and apply_window().