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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyQa40x-i2c
-Version: 0.2.0
+Version: 0.3.0
 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.3.0/RELEASE_NOTES.md

@@ -0,0 +1,27 @@
+### 0.3.0
+
+[MINOR] `Analyzer.init()` accepts `usb_serial` to open a specific QA402/QA403 by its USB serial number, so a PC with several analyzers can drive a chosen one. The argument is last and optional; without it the first analyzer found is opened, exactly as before.
+
+### 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 
+
+### 0.1.2
+
+[PATCH] Fix usb teardown deadlock.
+
+### 0.1.1
+
+[PATCH] Fix missing dependency.
+
+### 0.1.0
+
+[MINOR] Initial release as PyQa40x-i2c fork. Unlimited audio samples capture added.

{pyqa40x_i2c-0.2.0 → pyqa40x_i2c-0.3.0}/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.3.0'
+__version_tuple__ = version_tuple = (0, 3, 0)
 
-__commit_id__ = commit_id = 'g6a5ba3357'
+__commit_id__ = commit_id = 'geab2d8779'

{pyqa40x_i2c-0.2.0 → pyqa40x_i2c-0.3.0}/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,23 @@ 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
+    VENDOR_ID = 0x16C0
+    PRODUCT_IDS = (0x4E37, 0x4E39)  # QA402, QA403
 
     def __init__(self):
         """
@@ -25,6 +36,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
@@ -36,6 +48,55 @@ class Analyzer:
         self._dac_writer: threading.Thread | None = None  # set in start_capture()
         self._dac_writer_error: Exception | None = None  # error from DAC writer thread
 
+    def _open_analyzer(self, usb_serial: str | None = None):
+        """
+        Opens a QA402/QA403 analyzer on the USB bus.
+
+        Args:
+            usb_serial (str | None): USB serial number of the analyzer to open.
+                None opens the first analyzer found, which is the behaviour of
+                every release before serial selection was added.
+
+        Returns:
+            usb1.USBDeviceHandle: Handle of the opened analyzer.
+
+        Raises:
+            SystemExit: If no analyzer is connected, or if none of the connected
+                analyzers has the requested serial number.
+        """
+        if usb_serial is None:
+            for product_id in self.PRODUCT_IDS:
+                device = self.context.openByVendorIDAndProductID(
+                    self.VENDOR_ID, product_id
+                )
+                if device is not None:
+                    return device
+            raise SystemExit("No QA402/QA403 analyzer found")
+
+        connected: list[str] = []
+        for device in self.context.getDeviceList(skip_on_error=True):
+            if (
+                device.getVendorID() != self.VENDOR_ID
+                or device.getProductID() not in self.PRODUCT_IDS
+            ):
+                continue
+            try:
+                serial = device.getSerialNumber()
+            except usb1.USBError as error:
+                # Unreadable serial (usually missing udev permissions): the
+                # device cannot be matched, so report it as unknown.
+                logging.warning("Cannot read serial of a QA40x analyzer: %s", error)
+                serial = None
+            if serial == usb_serial:
+                logging.info("Opening QA40x analyzer with serial %s", serial)
+                return device.open()
+            connected.append(repr(serial))
+
+        raise SystemExit(
+            f"No QA402/QA403 analyzer with serial {usb_serial!r} found "
+            f"(connected: {', '.join(connected) or 'none'})"
+        )
+
     def init(
         self,
         sample_rate: int = 48000,
@@ -48,6 +109,7 @@ class Analyzer:
         amplitude_unit: str = "dbv",
         distortion_unit: str = "db",
         bt_device_name: str = "",
+        usb_serial: str | None = None,
     ) -> AnalyzerParams:
         """
         Initializes the analyzer hardware with the specified parameters.
@@ -63,6 +125,9 @@ class Analyzer:
             amplitude_unit (str): Unit for amplitude measurements, default is "dbv".
             distortion_unit (str): Unit for distortion measurements, default is "db".
             bt_device_name (str): Name of the Bluetooth device to use. Default is empty.
+            usb_serial (str | None): USB serial number of the analyzer to open,
+                e.g. "4334_E3B6". Needed only when several analyzers are
+                connected. Default None opens the first QA402/QA403 found.
 
         Returns:
             AnalyzerParams: A class instance containing the hardware and parameter settings.
@@ -78,21 +143,18 @@ 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
-        if self.device is None:
-            self.device = self.context.openByVendorIDAndProductID(
-                0x16C0, 0x4E39
-            )  # QA403
-            if self.device is None:
-                raise SystemExit("No QA402/QA403 analyzer found")
+        # Attempt to open the requested QA402/QA403 device, or the first one
+        self.device = self._open_analyzer(usb_serial)
         self.device.resetDevice()
         self.device.claimInterface(0)
 
         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 +274,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 +339,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.3.0}/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.3.0}/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.3.0}/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.3.0}/src/PyQa40x_i2c.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyQa40x-i2c
-Version: 0.2.0
+Version: 0.3.0
 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.3.0}/src/PyQa40x_i2c.egg-info/scm_file_list.json

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

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

@@ -0,0 +1,8 @@
+{
+  "tag": "0.3.0",
+  "distance": 0,
+  "node": "geab2d87790fb78dcedbb2918bc95d4b682060108",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-08-24"
+}

pyqa40x_i2c-0.2.0/RELEASE_NOTES.md

@@ -1,15 +0,0 @@
-### 0.2.0
-
-[MINOR] Add endless audio capturing 
-
-### 0.1.2
-
-[PATCH] Fix usb teardown deadlock.
-
-### 0.1.1
-
-[PATCH] Fix missing dependency.
-
-### 0.1.0
-
-[MINOR] Initial release as PyQa40x-i2c fork. Unlimited audio samples capture added.

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"
-}