{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Function definition and simple test data generation\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"%matplotlib widget\n",
"import subprocess\n",
"import os\n",
"import time\n",
"from enum import Enum\n",
"import multiprocessing\n",
"\n",
"import ipywidgets as widgets\n",
"import numpy as np\n",
"from scipy import signal\n",
"import soundfile as sf\n",
"from helper import setup_timeplot, setup_freqplot, plot_freqdomain, plot_timedomain\n",
"\n",
"# Chirp data generate\n",
"n=2000 # number of samples to use for the chirp\n",
"fs_chirp=20000 # The sampling rate for the chrip\n",
"f0=100# the start frequency in Hz for the chirp\n",
"f1=1000 # the stop frequency of the chirp\n",
"t1=n/fs_chirp # the total length of the chirp in s\n",
"\n",
"f_noise_hz=2000\n",
"disturber_amplitude=0.2\n",
"chirp_disturber_full_amp=0.6\n",
"#shift_disturber=64\n",
"#shift_signal=64\n",
"\n",
"t = np.linspace(0, t1, n)\n",
"# generate a chrip and scale to int16 (1 bit for sign)\n",
"y_signal_chirp = signal.chirp(t, f0=f0, f1=f1, t1=t1, method='linear')\n",
"y_signal_chirp = (chirp_disturber_full_amp-disturber_amplitude)*y_signal_chirp*(2**(15-1))\n",
"\n",
"# Add some a disturber to the chirp\n",
"y_sine = np.sin(2*np.pi*f_noise_hz*t) * disturber_amplitude* (2**(15-1))\n",
"y_noise = np.random.normal(0, disturber_amplitude, n) * (2**(15-1))\n",
"\n",
"y_signal_disturber = y_signal_chirp + y_sine\n",
"\n",
"# shift the signals relative to each other relative to the signal\n",
"#y_disturber = np.append([0]* shift_disturber, y_disturber[:-1*shift_disturber])\n",
"#y_signal_disturber = np.append([0]* shift_signal, y_signal_disturber[:-1*shift_signal])\n",
"\n",
"#y_disturber = disturber_amplitude*np.sin(2*np.pi*f_noise_hz*t + np.pi)* (2**(15-1))\n",
"\n",
"y_signal_disturber = y_signal_disturber.astype(int)\n",
"y_sine = y_sine.astype(int)\n",
"\n",
"# Save the data to a file - this allows for usage of the the debugger\n",
"np.savetxt('testdata/input/chirp.txt', y_signal_chirp, fmt='%d')\n",
"np.savetxt('testdata/input/chirp_disturber.txt', y_signal_disturber, fmt='%d', delimiter=\"\\n\")\n",
"np.savetxt('testdata/input/disturber.txt', y_sine, fmt='%d', delimiter=\"\\n\")\n",
"\n",
"con = np.stack((y_signal_disturber.astype(np.int16), y_sine.astype(np.int16)), axis=1)\n",
"sf.write('testdata/input/chirp_sine.wav', con, fs_chirp)\n",
"con = np.stack(((y_signal_chirp + y_noise).astype(np.int16), y_noise.astype(np.int16)), axis=1)\n",
"sf.write('testdata/input/chirp_noise.wav', con, fs_chirp)\n",
"con = np.stack(((y_sine + y_noise).astype(np.int16), y_noise.astype(np.int16)), axis=1)\n",
"sf.write('testdata/input/sine_noise.wav', con, fs_chirp)\n",
"\n",
"class OutputMode(Enum): \n",
" OUTPUT_MODE_C_SENSOR = 0\n",
" OUTPUT_MODE_ACC_SENSOR = 1\n",
" OUTPUT_MODE_FIR_LMS = 2\n",
" OUTPUT_MODE_FIR = 3\n",
"\n",
"def load_wav(filename):\n",
" y, fs = sf.read(filename, dtype='int16')\n",
" return fs, y.T\n",
"\n",
"def save_wav(filename, fs, cSensor, accSensor, output):\n",
" con = np.stack((cSensor, accSensor, output), axis=1)\n",
" sf.write(filename, con, fs)\n",
"\n",
"def compile(target='./build/cSensor_processing_single'):\n",
" # Build\n",
" ret = subprocess.call(['make', '-B', target])# , \"compile_cmd_opt=-O2\"\n",
" assert ret == 0, \"build failed\"\n",
"\n",
"def pipe_input_output(cSensor, accSensor, target='./build/cSensor_processing_single', output_mode = OutputMode.OUTPUT_MODE_FIR_LMS.value, timeout=10):\n",
" # Run\n",
" # open a pipe\n",
" process = subprocess.Popen(\n",
" [\n",
" target,\n",
" str(output_mode),\n",
" \"1\", #pipe_input true]\n",
" \"1\" # return coeffs\n",
" ], \n",
" stdin=subprocess.PIPE, \n",
" stdout=subprocess.PIPE, \n",
" universal_newlines=True, \n",
" #close_fds=False,\n",
" )\n",
"\n",
" # check that the data is the same length\n",
" assert len(cSensor) == len(accSensor)\n",
"\n",
" data=\"\".join(\n",
" [f\"{d1}\\n{d2}\\n\"for (d1,d2) in zip(cSensor, accSensor)]\n",
" )\n",
"\n",
" from io import StringIO\n",
" import pandas as pd\n",
"\n",
" c_output = process.communicate(input=data, timeout=timeout)\n",
" \n",
" out = StringIO(c_output[0])\n",
"\n",
" df = pd.read_csv(out, sep=\",\", dtype=str)\n",
"\n",
" # drop empty last column\n",
" df = df.iloc[:,:-1].astype(int)\n",
"\n",
" names= [\"out\"] + [f\"c{i}\" for i in range(df.shape[1] - 1)]\n",
" #name the columns \n",
" df = df.set_axis(names, axis=1)\n",
" \n",
" # send the data to the process and get the result\n",
" # check return code\n",
" assert process.returncode == 0, \"run failed\"\n",
"\n",
" return df\n",
" \n",
"def load_process_save(file, target, output_mode):\n",
" start=time.time()\n",
" base_dir=\"./testdata\"\n",
" fs, data = load_wav(f\"{base_dir}/input/{file}\")\n",
"\n",
" # spawn status text\n",
" progress_name=file[file.rfind(\"/\")+1: file.rfind(\".\")]\n",
" text = widgets.Label(value=progress_name)\n",
" text.value += \", Sampling rate: \" + str(fs)\n",
" display(text)\n",
"\n",
" # process the data and save\n",
" df=pipe_input_output(data[1], data[0], target=target, output_mode=output_mode)\n",
" save_wav(f\"{base_dir}/output/{file}\", fs, data[0], data[1], df[\"out\"][:len(data[0])])\n",
"\n",
" # finish status text\n",
" text.value+= f\", finished after {round((time.time()-start)/60, 1)} min\\n\"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Compile and run"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"ename": "AssertionError",
"evalue": "build failed",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mAssertionError\u001b[0m Traceback (most recent call last)",
"Cell \u001b[1;32mIn[3], line 4\u001b[0m\n\u001b[0;32m 1\u001b[0m build_target\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m./build/cSensor_processing_single\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m 2\u001b[0m output_mode \u001b[38;5;241m=\u001b[39m OutputMode\u001b[38;5;241m.\u001b[39mOUTPUT_MODE_FIR\u001b[38;5;241m.\u001b[39mvalue\n\u001b[1;32m----> 4\u001b[0m \u001b[38;5;28;43mcompile\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mtarget\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbuild_target\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 6\u001b[0m \u001b[38;5;66;03m# select the desired data\u001b[39;00m\n\u001b[0;32m 7\u001b[0m use_chirp \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n",
"Cell \u001b[1;32mIn[2], line 76\u001b[0m, in \u001b[0;36mcompile\u001b[1;34m(target)\u001b[0m\n\u001b[0;32m 73\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcompile\u001b[39m(target\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m./build/cSensor_processing_single\u001b[39m\u001b[38;5;124m'\u001b[39m):\n\u001b[0;32m 74\u001b[0m \u001b[38;5;66;03m# Build\u001b[39;00m\n\u001b[0;32m 75\u001b[0m ret \u001b[38;5;241m=\u001b[39m subprocess\u001b[38;5;241m.\u001b[39mcall([\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmake\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m-B\u001b[39m\u001b[38;5;124m'\u001b[39m, target])\u001b[38;5;66;03m# , \"compile_cmd_opt=-O2\"\u001b[39;00m\n\u001b[1;32m---> 76\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m ret \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbuild failed\u001b[39m\u001b[38;5;124m\"\u001b[39m\n",
"\u001b[1;31mAssertionError\u001b[0m: build failed"
]
}
],
"source": [
"\n",
"build_target='./build/cSensor_processing_single'\n",
"output_mode = OutputMode.OUTPUT_MODE_FIR.value\n",
"\n",
"compile(target=build_target)\n",
"\n",
"# select the desired data\n",
"use_chirp = True\n",
"plot_coeffs=True\n",
"if use_chirp: # Rather trivial input data in form of a chirp with sine as a disturber\n",
" cSensor= y_signal_disturber\n",
" accSensor= y_sine\n",
" df=pipe_input_output(cSensor, accSensor, target=build_target, output_mode=output_mode)\n",
" setup_timeplot(plot_coeffs=plot_coeffs)\n",
" #setup_freqplot()\n",
" if plot_coeffs:\n",
" coeffs=df.iloc[:, 1:]\n",
" else: \n",
" coeffs=None\n",
" plot_timedomain(cSensor, accSensor, df[\"out\"], coeffs=coeffs)\n",
" #plot_freqdomain(fs_chirp, cSensor, accSensor, output)\n",
"else:\n",
" single_file=False\n",
"\n",
" input_dir=\"./testdata/input\"\n",
" output_dir=\"./testdata/output\"\n",
" os.makedirs(output_dir, exist_ok=True)\n",
"\n",
" if single_file:\n",
" file = \"breathing_peak_016g_external_Speaker_80dBSPL_PDM.wav\"\n",
" #file = \".1kHz_peak_1g_external_Speaker_0dBSPL_PDM.wav\" \n",
" load_process_save(file, build_target, output_mode)\n",
"\n",
" else:# all files\n",
" wav_files = [file for file in os.listdir(input_dir) if file.endswith(\".wav\")]\n",
" # process files in parallel \n",
" def calc(file):\n",
" load_process_save(file, build_target, output_mode)\n",
"\n",
" num_processes = int(multiprocessing.cpu_count()/2)\n",
" pool = multiprocessing.Pool(processes=num_processes)\n",
"\n",
" pool.map(calc, wav_files)\n",
" pool.close()\n",
" pool.join()\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Plot the generated data"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "dfbccdb3271643b0ba9bdb1b86fbff5b",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Dropdown(description='Select a file:', options=('1kHz_peak_1g_external_Speaker_0dBSPL_PDM.wav', 'breathing_pea…"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "691f1f6e69f947b2a5ef5d241bfcc18e",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Checkbox(value=True, description='Is APx data')"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "08efe8e78f6d4fe58304828923f3704c",
"version_major": 2,
"version_minor": 0
},
"image/png": "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",
"text/html": [
"\n",
" \n",
"
\n",
" Figure 0\n",
"
\n",
"
\n",
"
\n",
"
\n",
" Figure 1\n",
"
\n",
"
\n",
"