Recording samples from an analog microphone module results in wav file that sounds way too sped up. What am I doing wrong?

[arjndr]

I'm trying to record samples from an analog microphone module (MAX9814) using ADC, it kinda works but the audio is only 2 seconds long instead of 10 and it sounds way too sped up. I basically "ported" the code for waveform I found in this page showing how to make wav files in C.

P.S: I'm using the Seeed XIAO nRF52840 board

Here's the code:

#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/drivers/adc.h>
#include <zephyr/fs/fs.h>
#include <zephyr/sys/byteorder.h>
#include <ff.h>
#include <stdio.h>
#include <math.h>

#define SAMPLE_RATE 16000
#define BITS_PER_SAMPLE 16
#define RECORD_TIME 10

static FATFS fat_fs;

static struct fs_mount_t mp = {
    .type = FS_FATFS,
    .fs_data = &fat_fs,
};

static const char *mount_path = "/SD:";

static const struct adc_dt_spec dev_mic_adc = ADC_DT_SPEC_GET_BY_IDX(DT_PATH(zephyr_user), 0);

#define ADC_RESOLUTION 12
#define ADC_CHANNEL 0

unsigned int sampling_period_us;

/* MICROPHONE */
int16_t mic_sample_buffer;

void read_mic_sample(const struct adc_dt_spec *adc_dev) {
    const struct adc_sequence sequence = {
        .channels = BIT(ADC_CHANNEL),
        .buffer = &mic_sample_buffer,
        .buffer_size = sizeof(mic_sample_buffer),
        .resolution = ADC_RESOLUTION,
    };

    if (adc_read(adc_dev->dev, &sequence) != 0) {
        printk("ADC reading failed\n");
    }
}

/* WAV FILE */
void write_le(unsigned int word, int num_bytes, struct fs_file_t *wav_file) {
    unsigned buf;
    while (num_bytes > 0) {
        buf = word & 0xff;
        fs_write(wav_file, &buf, 1);
        num_bytes--;
        word >>= 8;
    }
}

void write_bytes(struct fs_file_t *file, const void *data, size_t size) {
    fs_write(file, data, size);
}

void write_sample(struct fs_file_t *file, uint16_t sample, uint16_t bytes_per_sample) {
    write_le(sample, bytes_per_sample, file);
}

void write_wav_header(struct fs_file_t *file, uint32_t sample_rate, uint16_t bytes_per_sample, uint32_t num_samples, uint32_t channels) {
    printf("Writing WAV header with the following data:\nSAMPLE RATE: %d\nBYTES PER SAMPLE: %d\nTOTAL SAMPLES: %d\n", sample_rate, bytes_per_sample, num_samples);
    uint16_t byte_rate = sample_rate * channels * bytes_per_sample;

    // RIFF header
    write_bytes(file, "RIFF", 4);
    write_le(36 + bytes_per_sample * num_samples * channels, 4, file);
    write_bytes(file, "WAVE", 4);

    // fmt subchunk
    write_bytes(file, "fmt ", 4);

    write_le(16, 4, file); // Sub chunk 1 size
    write_le(1, 2, file); // PCM format
    write_le(channels, 2, file); // Channels
    write_le(sample_rate, 4, file); // Sample rate
    write_le(byte_rate, 4, file); // Byte rate
    write_le(channels * bytes_per_sample, 2, file); // Block Align
    write_le(8 * bytes_per_sample, 2, file); // Bits per sample

    write_bytes(file, "data", 4);
    write_le(bytes_per_sample * num_samples * channels, 4, file);
}

/* MAIN */
int main(void) {
	k_msleep(5000);

    sampling_period_us = round(1000000 * (1.0 / SAMPLE_RATE));

    if (!adc_is_ready_dt(&dev_mic_adc)) {
        printf("ADC not ready!\n");
        return 0;
    }

    int res = adc_channel_setup_dt(&dev_mic_adc);
    if (res != 0) {
        printf("ADC channel setup failed! Err: %d\n", res);
        return 0;
    }

    mp.mnt_point = mount_path;

    res = fs_mount(&mp);
    if (res != FR_OK) {
        printf("Mount failed!\n");
        return 0;
    } else {
        printf("Mounted successfully!\n");
    }

    // Record 10 seconds and save to SD
    int start_time = k_uptime_get();

    struct fs_file_t sound_file;
    fs_file_t_init(&sound_file);

    fs_open(&sound_file, "/SD:/mic.wav", FS_O_WRITE | FS_O_APPEND | FS_O_CREATE);

    write_wav_header(&sound_file, SAMPLE_RATE, 2, SAMPLE_RATE * RECORD_TIME, 1);

    printf("Recording..\n");

    while (k_uptime_get() - start_time < RECORD_TIME * 1000) {
        read_mic_sample(&dev_mic_adc);
        write_sample(&sound_file, mic_sample_buffer, 2);
        k_sleep(K_USEC(sampling_period_us));
    }

    printf("Finished recording!\n");

    fs_close(&sound_file);
    return 0;
}

Here's my DTS:

/ {
	zephyr,user {
		io-channels = <&adc 0>;
	};
};

&spi2 {
	status = "okay";

	cs-gpios = < &gpio0 3 GPIO_ACTIVE_LOW >;

	sdhc0: sdhc@0 {
		compatible = "zephyr,sdhc-spi-slot";
		reg = < 0 >;
		status = "okay";
		spi-max-frequency = < 25000000 >;
		mmc {
			compatible = "zephyr,sdmmc-disk";
			status = "okay";
		};
	};
};

&adc {
	status = "okay";
	#address-cells = <1>;
	#size-cells = <0>;

	channel@0 {
		reg = <0>;
		zephyr,gain = "ADC_GAIN_1_6";
		zephyr,reference = "ADC_REF_INTERNAL";
		zephyr,acquisition-time = <ADC_ACQ_TIME_DEFAULT>;
		zephyr,input-positive = <NRF_SAADC_AIN0>; /* P0.02 */
		zephyr,resolution = <12>;
	};
};

[ndrs-pst]

@arjndr The issue lies in the following piece of code where the execution time of read_mic_sample, write_sample, and even k_sleep accumulates, resulting in a recording that is only 2 seconds long instead of the intended 10 seconds.

while (k_uptime_get() - start_time < RECORD_TIME * 1000) {
        read_mic_sample(&dev_mic_adc);
        write_sample(&sound_file, mic_sample_buffer, 2);
        k_sleep(K_USEC(sampling_period_us));
    }

Just an idea, though not the actual solution:

Instead of using k_sleep and k_uptime_get() to check for expiration, the read_mic_sample function should be called using a timer, as described in the Zephyr timer documentation, and signal a semaphore to the main thread to write_sample.