PyQa40x-i2c 0.2.0__tar.gz → 0.2.2__tar.gz

{pyqa40x_i2c-0.2.0 → pyqa40x_i2c-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyQa40x-i2c
-Version: 0.2.0
+Version: 0.2.2
 Summary: A Python library for the QA40x audio analyser (int2code fork)
 Maintainer-email: Hubert Stepniewski <hubert.stepniewski@int2code.com>
 License: MIT License

{pyqa40x_i2c-0.2.0 → pyqa40x_i2c-0.2.2}/RELEASE_NOTES.md

@@ -1,3 +1,11 @@
+### 0.2.2
+
+[PATCH] Allow reliable streaming for higher sample rates (`96kHz`, `192kHz`).
+
+### 0.2.1
+
+[PATCH] Restore removed `Analyzer.send_receive` functionality.
+
 ### 0.2.0
 
 [MINOR] Add endless audio capturing 

{pyqa40x_i2c-0.2.0 → pyqa40x_i2c-0.2.2}/src/PyQa40x/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.0'
-__version_tuple__ = version_tuple = (0, 2, 0)
+__version__ = version = '0.2.2'
+__version_tuple__ = version_tuple = (0, 2, 2)
 
-__commit_id__ = commit_id = 'g6a5ba3357'
+__commit_id__ = commit_id = 'gf75dc49b9'

{pyqa40x_i2c-0.2.0 → pyqa40x_i2c-0.2.2}/src/PyQa40x/analyzer.py

@@ -1,5 +1,6 @@
 import threading
 import logging
+import struct
 
 import numpy as np
 import usb1  # pip install libusb1
@@ -11,13 +12,20 @@ from PyQa40x.stream import Stream
 from PyQa40x.helpers import *
 from PyQa40x.analyzer_params import AnalyzerParams
 from PyQa40x.bluetooth import BluetoothAudioDevice
+from PyQa40x.wave_sine import Wave
 
 logger = logging.getLogger(__name__)
 
+# Sample rate Hz vs bytes per USB transfer
+TRANSFER_BYTES_MAP = {
+    44100: Stream.DEFAULT_TRANSFER_BYTES,
+    48000: Stream.DEFAULT_TRANSFER_BYTES,
+    96000: 32768,
+    192000: 65536,
+}
 
-class Analyzer:
 
-    CAPTURE_CHUNK_BYTES = Stream.TRANSFER_BYTES  # bytes per USB transfer
+class Analyzer:
 
     def __init__(self):
         """
@@ -25,6 +33,7 @@ class Analyzer:
         """
         self.params: AnalyzerParams | None = None
         self.context: usb1.USBContext | None = None
+        self.chunk_size: int | None = None
         self.device: usb1.USBDeviceHandle | None = None
         self.registers: Registers | None = None
         self.control: Control | None = None
@@ -78,6 +87,7 @@ class Analyzer:
         )
         self.context = usb1.USBContext()
         self.context.open()
+        self.chunk_size = TRANSFER_BYTES_MAP.get(sample_rate, Stream.DEFAULT_TRANSFER_BYTES)
 
         # Attempt to open QA402 or QA403 device
         self.device = self.context.openByVendorIDAndProductID(0x16C0, 0x4E37)  # QA402
@@ -92,7 +102,7 @@ class Analyzer:
 
         self.registers = Registers(self.device)
         self.control = Control(self.registers)
-        self.stream = Stream(self.context, self.device, self.registers)
+        self.stream = Stream(self.context, self.device, self.registers, self.chunk_size)
 
         # Load calibration data
         self.cal_data = self.control.load_calibration()
@@ -212,7 +222,7 @@ class Analyzer:
         """Continuously submit zero-DAC / ADC-read transfer pairs while capturing."""
         while self._capturing and self.stream.running:
             try:
-                self.stream.write_zeros(self.CAPTURE_CHUNK_BYTES)
+                self.stream.write_zeros(self.chunk_size)
             except Exception as exc:  # pylint: disable=broad-except
                 # Racing with stop() is expected; a real failure while we still
                 # expect to run is recorded in the post-loop reconciliation below.
@@ -277,6 +287,120 @@ class Analyzer:
         if self._dac_writer is not None:
             self._dac_writer.join(timeout=5.0)
 
+    def send_receive(self, left_wave: Wave, right_wave: Wave) -> tuple[Wave, Wave]:
+        """
+        Sends DAC data to the device and receives ADC data.
+
+        Args:
+            left_wave (Wave): Wave instance with left channel DAC data.
+            right_wave (Wave): Wave instance with right channel DAC data.
+
+        Returns:
+            tuple[Wave, Wave]: Tuple containing Wave instances with left and right channel ADC data.
+        """
+        left_dac_data = left_wave.get_buffer()
+        right_dac_data = right_wave.get_buffer()
+
+        # On QA402 and QA403, outputs need to be swapped
+        left_dac_data, right_dac_data = right_dac_data, left_dac_data
+
+        left_peak = np.max(left_dac_data)
+
+        # Get calibration factors for outgoing data
+        cal_dac_left, cal_dac_right = self.control.get_dac_cal(
+            self.cal_data, self.params.max_output_level
+        )
+
+        # Convert to dBFS. Note the 3 dB adjustment--dBFS is peak, while dBV is RMS
+        dac_dbfs_adjustment = 10 ** -((self.params.max_output_level + 3) / 20)
+
+        # Apply calibration and dBFS scaling
+        left_dac_data = left_dac_data * dac_dbfs_adjustment * cal_dac_left
+        right_dac_data = right_dac_data * dac_dbfs_adjustment * cal_dac_right
+
+        # Convert incoming doubles to float
+        left_dac_data_float = left_dac_data.astype(np.float32)
+        right_dac_data_float = right_dac_data.astype(np.float32)
+
+        # Interleave the left and right channels
+        interleaved_dac_data = np.empty(
+            (left_dac_data_float.size + right_dac_data_float.size,), dtype=np.float32
+        )
+        interleaved_dac_data[0::2] = left_dac_data_float
+        interleaved_dac_data[1::2] = right_dac_data_float
+
+        # Convert to bytes, multiplying by max int value
+        max_int_value = 2 ** 31 - 1
+        interleaved_dac_data = (interleaved_dac_data * max_int_value).astype(np.int32)
+
+        num_ints_per_chunk = self.chunk_size // 4  # 32-bit ints, so 4 bytes per int
+        total_chunks = len(interleaved_dac_data) // num_ints_per_chunk
+
+        self.stream.start()
+
+        # Play wave on Bluetooth if available
+        bt_thread = None
+        if self.bt_device:
+            # Play both left and right waves on Bluetooth
+            bt_thread = self.bt_device.play_wave_background(left_wave, right_wave)
+
+        try:
+            for i in range(total_chunks):
+                chunk = interleaved_dac_data[
+                        i * num_ints_per_chunk: (i + 1) * num_ints_per_chunk
+                        ]
+                buffer = struct.pack("<%di" % len(chunk), *chunk)
+                self.stream.write(buffer)
+        finally:
+            self.stream.stop()
+
+        # Collect ADC data. This is bytes
+        interleaved_adc_data = self.stream.collect_remaining_adc_data()
+
+        # Wait for the Bluetooth thread to finish after processing
+        if bt_thread:
+            bt_thread.join()
+
+        # Convert collected ADC data back to int
+        interleaved_adc_data = np.frombuffer(interleaved_adc_data, dtype=np.int32)
+
+        # Separate interleaved ADC data into left and right channels. This is int
+        left_adc_data_int = interleaved_adc_data[0::2]
+        right_adc_data_int = interleaved_adc_data[1::2]
+
+        # Convert left and right channels back to double
+        left_adc_data = left_adc_data_int.astype(np.float64) / max_int_value
+        right_adc_data = right_adc_data_int.astype(np.float64) / max_int_value
+
+        # Get calibration factors for incoming data
+        cal_adc_left, cal_adc_right = self.control.get_adc_cal(
+            self.cal_data, self.params.max_input_level
+        )
+
+        # Convert from dBFS to dBV. Note the 6 dB factor--the ADC is differential
+        adc_dbfs_correction = 10 ** ((self.params.max_input_level - 6) / 20)
+
+        # Apply calibration and dBFS scaling
+        left_adc_data = left_adc_data * cal_adc_left * adc_dbfs_correction
+        right_adc_data = right_adc_data * cal_adc_right * adc_dbfs_correction
+
+        # Ensure the buffer matches the expected shape. Is this needed?
+        expected_shape = (
+            self.params.pre_buf + self.params.fft_size + self.params.post_buf,
+        )
+        if left_adc_data.shape[0] != expected_shape[0]:
+            left_adc_data = np.resize(left_adc_data, expected_shape)
+        if right_adc_data.shape[0] != expected_shape[0]:
+            right_adc_data = np.resize(right_adc_data, expected_shape)
+
+        # Create instances of Wave with the full buffers
+        left_wave = Wave(self.params)
+        right_wave = Wave(self.params)
+        left_wave.set_buffer(left_adc_data)
+        right_wave.set_buffer(right_adc_data)
+
+        return left_wave, right_wave
+
     def capture(self, total_samples: int) -> tuple[np.ndarray, np.ndarray]:
         """
         Captures ``total_samples`` samples from both ADC input channels without

{pyqa40x_i2c-0.2.0 → pyqa40x_i2c-0.2.2}/src/PyQa40x/control.py

@@ -46,7 +46,7 @@ class Control:
         """
         val = self.samplerate2reg[rate]
         self.registers.write(9, val)
-        time.sleep(0.1)  # A small delay to ensure the sample rate is set
+        time.sleep(0.2)  # A small delay to ensure the sample rate is set
 
     def load_calibration(self):
         """

{pyqa40x_i2c-0.2.0 → pyqa40x_i2c-0.2.2}/src/PyQa40x/stream.py

@@ -1,5 +1,7 @@
 import threading
 import queue
+import time
+
 import usb1
 import logging
 from typing import Callable
@@ -27,7 +29,7 @@ class Stream:
     """
 
     TRANSFER_TIMEOUT_MS = 1000  # Timeout for USB transfers in milliseconds
-    TRANSFER_BYTES = 16384  # 16 kB per USB bulk transfer (hardware chunk size)
+    DEFAULT_TRANSFER_BYTES = 16384  # 16 kB per USB bulk transfer (hardware chunk size)
     # cap on unread ADC data before overflow
     MAX_BUFFERED_BYTES = 256 * 1024 * 1024
 
@@ -36,6 +38,7 @@ class Stream:
         context: usb1.USBContext,
         device: usb1.USBDeviceHandle,
         registers: Registers,
+        transfer_bytes_size: int = DEFAULT_TRANSFER_BYTES
     ) -> None:
         """
         Initialize the Stream.
@@ -44,10 +47,12 @@ class Stream:
             context (usb1.USBContext): The USB context.
             device (usb1.USBDeviceHandle): The USB device handle.
             registers (Registers): The Registers instance for control writes.
+            transfer_bytes_size (int):
         """
         self.context = context
         self.device = device
         self.registers = registers
+        self.transfer_bytes_size = transfer_bytes_size  # USB bulk transfer (hardware chunk size)
         self.endpoint_read = usb1.ENDPOINT_IN | 0x02  # EP2 in
         self.endpoint_write = usb1.ENDPOINT_OUT | 0x02  # EP2 out
         self.dacQueue = queue.Queue(
@@ -79,7 +84,7 @@ class Stream:
         self._adc_data_carry = bytearray()  # leftover ADC bytes between consume_adc calls
         # latched, raised by consume_adc
         self._overflow_error: AdcOverflowError | None = None
-        self._max_queued_chunks = self.MAX_BUFFERED_BYTES // self.TRANSFER_BYTES
+        self._max_queued_chunks = self.MAX_BUFFERED_BYTES // self.transfer_bytes_size
 
     @property
     def overflow_error(self) -> "AdcOverflowError | None":
@@ -205,10 +210,26 @@ class Stream:
         self.dacQueue.put(dac)
         self.adcQueue.put(read)
 
-    def write_zeros(self, chunk_bytes: int = TRANSFER_BYTES) -> None:
+    def write_zeros(self, chunk_bytes: int = DEFAULT_TRANSFER_BYTES) -> None:
         """Feed the ADC pipeline with a zero DAC buffer (continuous capture)."""
         self.write(bytes(chunk_bytes))
 
+    def collect_remaining_adc_data(self):
+        """
+        Waits for all remaining ADC transfers to complete and returns the collected data.
+
+        Returns:
+            bytearray: The collected ADC data.
+        """
+        while not self.adcQueue.empty():
+            time.sleep(0.01)
+
+        while not self._adc_data.empty():
+            chunk = self._adc_data.get()
+            self._adc_data_carry.extend(chunk)
+
+        return self._adc_data_carry
+
     def consume_adc(
         self,
         need_bytes: int,

{pyqa40x_i2c-0.2.0 → pyqa40x_i2c-0.2.2}/src/PyQa40x/wave.py

@@ -26,7 +26,7 @@ class Wave:
 
         self.amplitude_unit: str = amplitude_unit  # Lowercase. Use dbv or dbu
         self.distortion_unit: str = distortion_unit  # Lowercase. Use db or pct
-        self.energy_unit: str = energy_unit  # Lowercase. Use dbv, dbu, V, or V�
+        self.energy_unit: str = energy_unit  # Lowercase. Use dbv, dbu, V or V^2
 
 
     def set_buffer(self, buffer: np.ndarray):

{pyqa40x_i2c-0.2.0 → pyqa40x_i2c-0.2.2}/src/PyQa40x_i2c.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyQa40x-i2c
-Version: 0.2.0
+Version: 0.2.2
 Summary: A Python library for the QA40x audio analyser (int2code fork)
 Maintainer-email: Hubert Stepniewski <hubert.stepniewski@int2code.com>
 License: MIT License

{pyqa40x_i2c-0.2.0 → pyqa40x_i2c-0.2.2}/src/PyQa40x_i2c.egg-info/scm_file_list.json

@@ -1,58 +1,58 @@
 {
   "files": [
-    ".gitignore",
-    "README.md",
-    ".pylint_ignore",
-    "requirements-test.txt",
+    "tox.ini",
     "requirements.txt",
+    "requirements-test.txt",
     "requirements-dev.txt",
-    "tox.ini",
-    "pyproject.toml",
     "MANIFEST.in",
-    "RELEASE_NOTES.md",
+    "pyproject.toml",
+    ".pylint_ignore",
     "LICENSE",
+    "RELEASE_NOTES.md",
+    "README.md",
+    ".gitignore",
+    ".github/workflows/code_checker.yml",
+    ".github/workflows/unit_tests.yml",
+    ".github/workflows/publish_package.yml",
+    "tests/__init__.py",
+    "tests/test_template.py",
+    "src/PyQa40x/sig_proc.py",
     "src/PyQa40x/wave.py",
-    "src/PyQa40x/math_general.py",
-    "src/PyQa40x/fft_processor.py",
-    "src/PyQa40x/wave_sine.py",
+    "src/PyQa40x/helpers.py",
     "src/PyQa40x/freq_series_plotter.py",
-    "src/PyQa40x/analyzer_params.py",
-    "src/PyQa40x/sig_proc.py",
-    "src/PyQa40x/control.py",
     "src/PyQa40x/math_sines.py",
-    "src/PyQa40x/analyzer.py",
-    "src/PyQa40x/helpers.py",
+    "src/PyQa40x/wave_sine.py",
     "src/PyQa40x/registers.py",
-    "src/PyQa40x/cross_correlation.py",
-    "src/PyQa40x/series_plotter.py",
     "src/PyQa40x/math_windows.py",
-    "src/PyQa40x/bluetooth.py",
     "src/PyQa40x/math_energy.py",
     "src/PyQa40x/math_chirp.py",
-    "src/PyQa40x/wave_chirp.py",
+    "src/PyQa40x/analyzer.py",
+    "src/PyQa40x/analyzer_params.py",
     "src/PyQa40x/__init__.py",
+    "src/PyQa40x/math_general.py",
+    "src/PyQa40x/control.py",
+    "src/PyQa40x/wave_chirp.py",
+    "src/PyQa40x/series_plotter.py",
+    "src/PyQa40x/fft_processor.py",
     "src/PyQa40x/stream.py",
-    "src/PyQa40x.egg-info/requires.txt",
+    "src/PyQa40x/cross_correlation.py",
+    "src/PyQa40x/bluetooth.py",
     "src/PyQa40x.egg-info/SOURCES.txt",
-    "src/PyQa40x.egg-info/top_level.txt",
     "src/PyQa40x.egg-info/dependency_links.txt",
+    "src/PyQa40x.egg-info/requires.txt",
     "src/PyQa40x.egg-info/PKG-INFO",
-    ".github/workflows/unit_tests.yml",
-    ".github/workflows/code_checker.yml",
-    ".github/workflows/publish_package.yml",
+    "src/PyQa40x.egg-info/top_level.txt",
     "_ci/is_dev_version.sh",
-    "LibTest/PyQa40x_cross_correlation.py",
-    "LibTest/PyQa40x_acoustic_chirp_spl_bt.py",
-    "LibTest/PyQa40x_acoustic_dbspl.py",
+    "LibTest/PyQa40x_thdn.py",
     "LibTest/PyQa40x_freq_response_with_mask.py",
-    "LibTest/PyQa40x_pinknoise.py",
-    "LibTest/PyQa40x_acoustic_energy_decay_bt.py",
     "LibTest/mask_phase.txt",
     "LibTest/PyQa40x_coherent_averaging.py",
-    "LibTest/PyQa40x_thdn.py",
     "LibTest/FirstPrinciples.py",
+    "LibTest/PyQa40x_cross_correlation.py",
+    "LibTest/PyQa40x_pinknoise.py",
     "LibTest/mask_freq.txt",
-    "tests/test_template.py",
-    "tests/__init__.py"
+    "LibTest/PyQa40x_acoustic_energy_decay_bt.py",
+    "LibTest/PyQa40x_acoustic_dbspl.py",
+    "LibTest/PyQa40x_acoustic_chirp_spl_bt.py"
   ]
 }

pyqa40x_i2c-0.2.2/src/PyQa40x_i2c.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.2.2",
+  "distance": 0,
+  "node": "gf75dc49b93b52857fb5f1d4ae3825e1a36fc7a30",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-08-06"
+}

pyqa40x_i2c-0.2.0/src/PyQa40x_i2c.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.2.0",
-  "distance": 0,
-  "node": "g6a5ba3357cf07c1d160ef5f122265823f2560ec9",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-07-16"
-}