PyQa40x-i2c 0.1.0__tar.gz

pyqa40x_i2c-0.1.0/.github/workflows/code_checker.yml

@@ -0,0 +1,22 @@
+name: Code-checker
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.12"]
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v3
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install .[dev]

pyqa40x_i2c-0.1.0/.github/workflows/publish_package.yml

@@ -0,0 +1,36 @@
+name: Publish Python Package
+
+on:
+  push:
+    tags:
+      - '*'
+  workflow_dispatch:
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # required for setuptools-scm to determine version from tags
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.12'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install build twine
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish to PyPI
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
+        run: python -m twine upload --verbose dist/*

pyqa40x_i2c-0.1.0/.github/workflows/unit_tests.yml

@@ -0,0 +1,37 @@
+name: Unit-tests
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.12"]
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v3
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install .[test]
+    - name: Run tests
+      run: |
+        pytest -vv --log-level DEBUG \
+        --cov src \
+        --cov-branch \
+        --cov-report html:reports/pytest_coverage \
+        --cov-fail-under 0 \
+        --junitxml=reports/junit/test-results-${{ matrix.python-version }}.xml
+    - name: Upload pytest test results
+      uses: actions/upload-artifact@v4
+      with:
+        name: reports-${{ matrix.python-version }}
+        path: |
+          reports
+      if: ${{ always() }}

pyqa40x_i2c-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+*.pyc
+*.wsuo
+*.json
+*.sqlite
+*.vsidx
+.vs/

pyqa40x_i2c-0.1.0/.pylint_ignore

@@ -0,0 +1 @@
+

pyqa40x_i2c-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 QuantAsylum
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyqa40x_i2c-0.1.0/LibTest/FirstPrinciples.py

@@ -0,0 +1,193 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.signal.windows import flattop, boxcar, hamming
+from scipy.fft import rfft, rfftfreq
+
+#
+# A standalone file that demonstrates how to preserve amplitudes
+# and energy measurements across changes in FFT size, windows, etc
+# using standard python libs
+
+# Define the parameters
+
+# FFT Size. Use power of two
+N = 4096
+
+# Sampel rate
+fs = 48000  
+
+# Target frequency in Hz. 
+f_target = 1000
+
+# Choose the window function
+window_function = 'hamming'  # Change to 'flattop', 'boxcar', or 'hamming'
+
+# This sets the target frequency adjustment strategy.
+# none will not make a change to the target frequency
+# snap will nudge the frequency to the center of the nearest bin
+# straddle will nudge the frequency such that it straddles two bins
+f_adjust_strategy = 'snap'  # Set to 'none', 'snap', or 'straddle'
+
+##################################
+##################################
+##################################
+
+bin_resolution = fs / N
+
+# Adjust f_target based on the provided strategy
+if f_adjust_strategy == 'snap':
+    f = round(f_target / bin_resolution) * bin_resolution
+elif f_adjust_strategy == 'straddle':
+    bin_index = round(f_target / bin_resolution)
+    f = (bin_index + 0.5) * bin_resolution
+else:
+    f = f_target
+
+t = np.arange(N) / fs  # Time vector
+
+# Create a sinusoidal signal with a peak amplitude of 1.41 = 0 dBV
+amplitude = 1.41
+signal = amplitude * np.sin(2 * np.pi * f * t)
+
+if window_function == 'flattop':
+    window = flattop(N)
+elif window_function == 'boxcar':
+    window = boxcar(N)
+elif window_function == 'hamming':
+    window = hamming(N)
+else:
+    raise ValueError("Unknown window function")
+
+# Compute the Amplitude Correction Factor (ACF). This factor is used to correct the
+# FFT results so that the amplitudes are correctly plotted. The ACF for a boxcar is 1.0
+mean_w = np.mean(window)
+ACF = 1 / mean_w
+
+# Compute the Energy Correction Factor (ECF). This factor is used to ensure accurate
+# energy calculations when integrating across the frequency domain. In the time domain,
+# the RMS (Root Mean Square) value of a signal can be calculated directly using the formula:
+# RMS = sqrt(mean(signal**2)). However, in the frequency domain, to accurately calculate
+# the RMS energy over a range of frequencies, RMS = sqrt(sum(signal**2))*ECF
+rms_w = np.sqrt(np.mean(window**2))
+ECF = 1 / rms_w
+
+# Print the window function, correction factors, frequencies, and bin size
+print(f"Window function: {window_function}")
+print(f"Amplitude Correction Factor (ACF): {ACF:.4f} ({20 * np.log10(ACF):.2f} dB)")
+print(f"Energy Correction Factor (ECF): {ECF:.4f} ({20 * np.log10(ECF):.2f} dB)")
+print(f"f_target: {f_target} Hz")
+print(f"f (adjusted): {f} Hz")
+print(f"Bin size: {bin_resolution:.2f} Hz")
+print(f"Frequency adjustment strategy: {f_adjust_strategy}")
+
+# Apply the selected window
+windowed_signal = signal * window
+
+# Perform the FFT and normalize. Normalizing means that, regardless of the FFT size, 
+# we'll still arrive at the same amplitude for a given time-domain signal Note the rfft
+# assumes real input data, and computes only the positive freq components
+fft_result = rfft(windowed_signal)
+fft_normalized = (np.abs(fft_result) / (N / 2)) / np.sqrt(2)
+
+# Apply the ACF to the entire FFT magnitude. With this step, a 0 dBV sine will have
+# a peak of 0 dBV
+fft_magnitude_acf = fft_normalized * ACF
+fft_magnitude_acf_dBV = 20 * np.log10(fft_magnitude_acf)  # Convert to dBV
+
+# Compute the frequencies corresponding to the positive half of the FFT
+frequencies = rfftfreq(N, d=1/fs)
+
+# Find the peak in the corrected FFT magnitude
+peak_index = np.argmax(fft_magnitude_acf)  # Consider only the positive frequencies
+plot_peak_frequency = peak_index * bin_resolution
+peak_amplitude = fft_magnitude_acf[peak_index]
+peak_amplitude_dBV = 20 * np.log10(peak_amplitude)
+
+# Compute the RMS energy of the entire spectrum (excluding DC and Nyquist bins)
+rms_energy_entire_spectrum = np.sqrt(np.sum(fft_normalized[1:]**2)) * ECF
+rms_energy_entire_spectrum_dBV = 20 * np.log10(rms_energy_entire_spectrum)
+
+# Compute the RMS energy from start frequency to stop frequency
+start_freq = 900
+stop_freq = 1100
+
+# Find the indices corresponding to start and stop frequencies
+start_index = np.searchsorted(frequencies, start_freq, side='left')
+stop_index = np.searchsorted(frequencies, stop_freq, side='right')
+
+# Compute the RMS energy within the specified frequency range
+rms_energy_range = np.sqrt(np.sum(fft_normalized[start_index:stop_index]**2)) * ECF
+rms_energy_range_dBV = 20 * np.log10(rms_energy_range)
+
+# Print frequency domain peak values
+print(f"Plot Peak Frequency: {plot_peak_frequency:.2f} Hz")
+print(f"Plot Peak Amplitude: {peak_amplitude:.4f} ({peak_amplitude_dBV:.2f} dBV)")
+print(f"RMS Energy of the Entire Spectrum (excluding DC and Nyquist): {rms_energy_entire_spectrum:.4f} ({rms_energy_entire_spectrum_dBV:.2f} dBV)")
+print(f"RMS Energy from {start_freq} Hz to {stop_freq} Hz: {rms_energy_range:.4f} ({rms_energy_range_dBV:.2f} dBV)")
+
+# Plot the window function, signal, and its FFT
+plt.figure(figsize=(12, 6))
+
+# Plot the window function
+plt.subplot(2, 2, 1)
+plt.plot(t, window, label='Window Function')
+plt.xlabel('Time [s]')
+plt.ylabel('Amplitude')
+plt.title('Window Function')
+plt.legend()
+plt.grid()
+
+# Plot the time domain signal
+plt.subplot(2, 2, 2)
+plt.plot(t, signal, label='Original Signal')
+plt.plot(t, windowed_signal, label='Windowed Signal')
+plt.xlabel('Time [s]')
+plt.ylabel('Amplitude')
+plt.title('Time Domain Signal')
+plt.legend()
+plt.grid()
+
+# Plot the FFT magnitude
+plt.subplot(2, 2, 3)
+ax3 = plt.gca()
+ax3.plot(frequencies, fft_magnitude_acf, label='Magnitude', color='b')
+ax3.set_xlabel('Frequency [Hz]')
+ax3.set_ylabel('Magnitude')
+ax3.set_title('Frequency Domain (FFT)')
+ax3.grid()
+
+# Add a secondary y-axis to show dBV
+ax3_right = ax3.twinx()
+ax3_right.plot(frequencies, fft_magnitude_acf_dBV, color='r', alpha=0.5, linestyle='--', label='Magnitude (dBV)')
+ax3_right.set_ylabel('Magnitude (dBV)')
+ax3_right.grid(False)
+
+# Combine legends
+lines, labels = ax3.get_legend_handles_labels()
+lines2, labels2 = ax3_right.get_legend_handles_labels()
+ax3_right.legend(lines + lines2, labels + labels2, loc='upper right')
+
+# Plot a zoomed-in view of +/- 10 bins from the center frequency
+plt.subplot(2, 2, 4)
+ax4 = plt.gca()
+zoom_start = max(0, peak_index - 10)
+zoom_end = min(len(frequencies), peak_index + 11)
+ax4.plot(frequencies[zoom_start:zoom_end], fft_magnitude_acf[zoom_start:zoom_end], label='Magnitude', color='b')
+ax4.set_xlabel('Frequency [Hz]')
+ax4.set_ylabel('Magnitude')
+ax4.set_title(f'Zoomed-in View (+/- 10 bins) around {plot_peak_frequency:.2f} Hz')
+ax4.grid()
+
+# Add a secondary y-axis to show dBV
+ax4_right = ax4.twinx()
+ax4_right.plot(frequencies[zoom_start:zoom_end], fft_magnitude_acf_dBV[zoom_start:zoom_end], color='r', alpha=0.5, linestyle='--', label='Magnitude (dBV)')
+ax4_right.set_ylabel('Magnitude (dBV)')
+ax4_right.grid(False)
+
+# Combine legends
+lines, labels = ax4.get_legend_handles_labels()
+lines2, labels2 = ax4_right.get_legend_handles_labels()
+ax4_right.legend(lines + lines2, labels + labels2, loc='upper right')
+
+plt.tight_layout()
+plt.show()

pyqa40x_i2c-0.1.0/LibTest/PyQa40x_acoustic_chirp_spl_bt.py

@@ -0,0 +1,131 @@
+import os
+import sys
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+sys.path.insert(0, os.path.abspath(os.path.join(sys.path[0], '..', 'src')))
+
+from PyQa40x.analyzer import Analyzer
+from PyQa40x.wave_chirp import WaveChirp
+from PyQa40x.series_plotter import SeriesPlotter
+from PyQa40x.math_general import *
+import PyQa40x.math_chirp as mc
+
+# Python code used to sweep the frequency response of a speaker.
+
+#
+# User Options
+#
+
+# Set sample rate
+sample_rate = 48000
+
+# If we enable this with the QA40x in loopback, then the dBSPL will be reported as 
+# as db_spl_at_0dbv. Bluetooth will not be used if doing a loopback test
+test_loopback = False
+
+# Set to true to see a list of available bluetooth devices. This will list the
+# devices for the sample rate specified above and then exit
+bluetooth_list_devices = False
+
+# Specify the name of your bluetooth device here. The chirp will be mirrored to that
+# device.
+bluetooth_device = "SineAudio DS6301+"
+bluetooth_device = "I13"
+#bluetooth_device = ""
+
+# if true, then a tight IR window will be applied. Otherwise, a looser window to take
+# room characteristics into account
+is_headphones = True
+
+# Define chirp amplitude to be used in dBV. This will be used if
+# bluetooth isn't being used OR if test_loopback is specified
+chirp_amp_dbv = 0
+
+# Define chirp amplitude to used in dBFS. This will be used if
+# blueotooth is used
+chirp_amp_dbfs = -5
+
+# Mute left or right as desired
+mute_left_dac = False
+mute_right_dac = False
+
+# Setup external gains and sensitivities
+mic_ref_level_dbspl = 94            # Mic sense reference level
+mic_sense_dbv_at_ref_level = -28.9  # Earthworks M23R
+preamp_gain = 0                     # QA472
+
+# Define a quantity for this combination of mic and pre-amp: What is the dBSPL
+# measured when 0 dBV is seen at inputs
+db_spl_at_0dbv = mic_ref_level_dbspl - mic_sense_dbv_at_ref_level - preamp_gain
+
+#
+# Make measurement
+#
+
+# if loopback test, override any bluetooth devices
+if (test_loopback):
+    bluetooth_device = ""
+
+if bluetooth_list_devices:
+    Analyzer.list_audio_devices_by_sample_rate(sample_rate)
+    sys.exit()
+
+# Create an Analyzer instance
+analyzer = Analyzer()
+
+# Initialize the analyzer with desired parameters
+params = analyzer.init(sample_rate=sample_rate, max_input_level=6, max_output_level=18, fft_size=2**17, bt_device_name=bluetooth_device, pre_buf=16384)
+
+# Dump key parameters
+print(params)
+
+# Create a chirp instance. Buffers are all zero'd (no sound)
+wave_dac_left = WaveChirp(params)
+wave_dac_right = WaveChirp(params)
+
+if test_loopback or bluetooth_device == "":
+    print(f"db_spl_at_0dbv: {db_spl_at_0dbv:0.1f}")
+    if mute_left_dac is False:
+        wave_dac_left = wave_dac_left.gen_chirp_dbv(chirp_amp_dbv)
+    if mute_right_dac is False:    
+        wave_dac_right = wave_dac_right.gen_chirp_dbv(chirp_amp_dbv)
+else:
+    if mute_left_dac is False:
+        wave_dac_left = wave_dac_left.gen_chirp_dbfs(chirp_amp_dbfs)
+    if mute_right_dac is False:    
+        wave_dac_right = wave_dac_right.gen_chirp_dbfs(chirp_amp_dbfs)    
+    
+# Send chirp to left channel.
+wave_adc_left, wave_adc_right = analyzer.send_receive(wave_dac_left, wave_dac_right)
+
+if is_headphones:
+    window_start_time = 0.003   # Seconds before IR peak
+    window_end_time = 0.02       # Seconds after IR peak
+    ramp_up_time = 0.001        # attack ramp period
+    ramp_down_time = 0.005       # decay ramp period
+else:
+    window_start_time = 0.010
+    window_end_time = 0.5
+    ramp_up_time = 0.005
+    ramp_down_time = 0.02 
+
+freq, fft_left, ir_left, window = wave_dac_left.compute_fft_db(wave_adc_left.get_main_buffer(), apply_window=True, window_start_time=window_start_time, window_end_time=window_end_time, ramp_up_time=ramp_up_time, ramp_down_time=ramp_down_time)
+freq, fft_right, ir_left, window = wave_dac_right.compute_fft_db(wave_adc_right.get_main_buffer(), apply_window=True, window_start_time=window_start_time, window_end_time=window_end_time, ramp_up_time=ramp_up_time, ramp_down_time=ramp_down_time)
+
+tsp = SeriesPlotter(num_columns=2)
+tsp.add_time_series(wave_dac_left.get_buffer(), "DAC Left")
+tsp.add_time_series(wave_dac_right.get_buffer(), "DAC Right")
+tsp.newrow()
+tsp.add_time_series(wave_adc_left.get_buffer(), "ADC Left")
+tsp.add_time_series(wave_adc_right.get_buffer(), "ADC Right")
+tsp.newrow()
+tsp.add_time_series(ir_left, "IR Left", signal_right = window)
+tsp.add_time_series(ir_left, "IR Right", signal_right = window)
+tsp.newrow
+tsp.add_freq_series(freq, fft_left + db_spl_at_0dbv, "FR Left dBSPL", logx=True, units="dBSPL", ymax=120, ymin=40)
+tsp.add_freq_series(freq, fft_right + db_spl_at_0dbv, "FR Right dBSPL", logx=True, units = "dBSPL", ymax=120, ymin=40)
+tsp.plot();
+
+analyzer.cleanup()

pyqa40x_i2c-0.1.0/LibTest/PyQa40x_acoustic_dbspl.py

@@ -0,0 +1,49 @@
+import os
+import sys
+import numpy as np
+import matplotlib.pyplot as plt
+
+sys.path.insert(0, os.path.abspath(os.path.join(sys.path[0], '..', 'src')))
+
+from PyQa40x.analyzer import Analyzer
+from PyQa40x.wave_sine import WaveSine
+from PyQa40x.series_plotter import SeriesPlotter
+from PyQa40x.helpers import linear_to_dBV
+
+# Setup mic constants below, and then using a mic calibrator, verify the plotted fft peak
+# matches the expected amplitude. For the test below, an M23R was used with a QA472 at 0 dB
+# of gain. A 94 dBSPL mic calibrator was used. The 1 kHz peak in the FFT measured 94.12 dBSPL.
+# Test was repeated at 114 dBSPL from the calibrator and also 10 dB from the pre-amp to 
+# verify the results were again expected.
+
+mic_ref_level_dbspl = 94            # Mic sense reference level
+mic_sense_dbv_at_ref_level = -28.9  # Earthworks M23R
+preamp_gain = 0                    # QA472
+
+dbSpl_at_0dbv = mic_ref_level_dbspl - mic_sense_dbv_at_ref_level - preamp_gain
+
+# Create an Analyzer instance
+analyzer = Analyzer()
+
+# Initialize the analyzer with desired parameters
+params = analyzer.init(sample_rate=48000, max_input_level=0, max_output_level=8, fft_size=2**14, window_type="flattop")
+
+# Dump key parameters
+print(params)
+
+# By default, generates silence
+ws = WaveSine(params)
+
+# Send the DAC buffers to the hardware, and collect the left ADC buffer
+wave_adc, _ = analyzer.send_receive(ws, ws)
+
+# Get amplitude array (defaults to dBV) and freq array
+adc_freq = wave_adc.get_frequency_array()
+adc_amp_dbv = wave_adc.get_amplitude_array()
+
+# Plot 
+tsp = SeriesPlotter(num_columns=2)
+tsp.add_freq_series(adc_freq, adc_amp_dbv + dbSpl_at_0dbv, "dBSPL", units="dBSPL")
+tsp.plot();
+
+analyzer.cleanup()

pyqa40x_i2c-0.1.0/LibTest/PyQa40x_acoustic_energy_decay_bt.py

@@ -0,0 +1,121 @@
+import os
+import sys
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+sys.path.insert(0, os.path.abspath(os.path.join(sys.path[0], '..', 'src')))
+
+from PyQa40x.analyzer import Analyzer
+from PyQa40x.wave_chirp import WaveChirp
+from PyQa40x.series_plotter import SeriesPlotter
+from PyQa40x.math_general import *
+import PyQa40x.math_chirp as mc
+
+# Python code used to play a chirp from a speaker or bluetooth, and measure the energy decay curve.
+# The QA403 output goes into a +20 dB power amp (QA462), and that goes into a speaker.
+# An SM58 mic is placed in the middle of the room to capture the chirp. That chirp
+# is then converted into an impulse response, and the energy of that IR is plotted.
+# The time for the energy to decay 20 dB is noted on the graph
+
+#
+# User Options
+#
+
+# Set sample rate
+sample_rate = 48000
+
+# If we enable this with the QA40x in loopback, then the dBSPL will be reported as 
+# as db_spl_at_0dbv. Bluetooth will not be used if doing a loopback test
+test_loopback = False
+
+# Set to true to see a list of available bluetooth devices. This will list the
+# devices for the sample rate specified above and then exit
+bluetooth_list_devices = False
+
+# Specify the name of your bluetooth device here. The chirp will be mirrored to that
+# device.
+#bluetooth_device = "SineAudio DS6301+"
+bluetooth_device = ""
+
+# Define chirp amplitude to be used in dBV. This will be used if
+# bluetooth isn't being used OR if test_loopback is specified
+chirp_amp_dbv = -10
+
+# Define chirp amplitude to used in dBFS. This will be used if
+# blueotooth is used
+chirp_amp_dbfs = -20
+
+# Mute left or right as desired
+mute_left_dac = False
+mute_right_dac = False
+
+mic_ref_level_dbspl = 94            # Mic sense reference level dBspl
+mic_sense_dbv_at_ref_level = -28.9  # Earthworks M23R
+preamp_gain = 0                     # QA472
+
+dbspl_at_0dbv = mic_ref_level_dbspl - mic_sense_dbv_at_ref_level - preamp_gain
+
+#
+# Make measurement
+#
+
+# if loopback test, override any bluetooth devices
+if (test_loopback):
+    bluetooth_device = ""
+    
+if bluetooth_list_devices == True:
+    Analyzer.list_audio_devices_by_sample_rate(sample_rate)
+    sys.exit()
+
+# Create an Analyzer instance
+analyzer = Analyzer()
+
+# Initialize the analyzer with desired parameters
+params = analyzer.init(sample_rate=sample_rate, max_input_level=6, max_output_level=18, fft_size=2**18, bt_device_name=bluetooth_device)
+
+# Dump key parameters
+print(params)
+
+wave_chirp = WaveChirp(params)
+
+if test_loopback or bluetooth_device == "":
+    print(f"db_spl_at_0dbv: {dbspl_at_0dbv:0.1f}")
+    if mute_left_dac is False:
+        wave_dac_left = wave_chirp.gen_chirp_dbv(chirp_amp_dbv)
+    if mute_right_dac is False:    
+        wave_dac_right = wave_chirp.gen_chirp_dbv(chirp_amp_dbv)
+else:
+    if mute_left_dac is False:
+        wave_dac_left = wave_chirp.gen_chirp_dbfs(chirp_amp_dbfs)
+    if mute_right_dac is False:    
+        wave_dac_right = wave_chirp.gen_chirp_dbfs(chirp_amp_dbfs)  
+
+# Send the DAC buffers to the hardware, and collect the left ADC buffer
+wave_adc_left, _ = analyzer.send_receive(wave_dac_left, wave_dac_right)
+
+# Remove DC
+wave_adc_left.remove_dc()
+
+# Compute peak RMS every 10 mS
+adc_dbspl, _ = wave_adc_left.compute_instantaneous_dbspl(dbspl_at_0dbv, 10)
+
+# Compute frequency response, applying a window around the impulse response
+req, fft, ir, window = wave_chirp.compute_fft_db(wave_adc_left.get_main_buffer(), window_start_time=0.05, window_end_time=2, ramp_up_time = 0.02, ramp_down_time=0.5, apply_window=True)
+
+# We're looking for the 20 dB decay point around the IR
+db_decay = 20
+
+# Apply the window and compute RT
+rt, edc_db, start_idx, end_idx = wave_chirp.compute_rt(ir, db_decay)
+
+# Plot 
+tsp = SeriesPlotter(num_columns=2)
+tsp.add_time_series(wave_adc_left.get_main_buffer(), "ADC")
+tsp.add_time_series(adc_dbspl, "ADC dBSPL")
+tsp.newrow()
+tsp.add_time_series(ir, "Room Impulse Response & Window", signal_right = window)
+tsp.add_time_series(edc_db, f"Energy Decay Curve ({db_decay}dB = {rt:.2f} sec)", ymax=10, ymin=-70)
+tsp.plot();
+
+analyzer.cleanup()