SCPI-Instrument-Control 1.0.0__tar.gz → 1.0.1__tar.gz

{scpi_instrument_control-1.0.0 → scpi_instrument_control-1.0.1}/CHANGELOG.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+
+## [1.0.1] - 2026-01-07
+
+### Added
+
+### Changed
+
+### Fixed
+
 ## [1.0.0] - 2026-01-06
 
 ### ⚠️ MAJOR RELEASE - Package Renamed

{scpi_instrument_control-1.0.0/SCPI_Instrument_Control.egg-info → scpi_instrument_control-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SCPI-Instrument-Control
-Version: 1.0.0
+Version: 1.0.1
 Summary: Universal Python library for controlling SCPI-compatible test equipment via Ethernet/LAN. Supports oscilloscopes (Siglent SDS series, generic SCPI scopes), function generators/AWGs (Siglent SDG series, generic SCPI AWGs), and power supplies (Siglent SPD series, generic SCPI PSUs). Features include waveform capture, measurements, FFT analysis, PyQt6 GUI, automated report generation with AI analysis, and comprehensive SCPI command abstraction.
 Author: Robin Mumm
 Maintainer: little-did-I-know

{scpi_instrument_control-1.0.0 → scpi_instrument_control-1.0.1/SCPI_Instrument_Control.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SCPI-Instrument-Control
-Version: 1.0.0
+Version: 1.0.1
 Summary: Universal Python library for controlling SCPI-compatible test equipment via Ethernet/LAN. Supports oscilloscopes (Siglent SDS series, generic SCPI scopes), function generators/AWGs (Siglent SDG series, generic SCPI AWGs), and power supplies (Siglent SPD series, generic SCPI PSUs). Features include waveform capture, measurements, FFT analysis, PyQt6 GUI, automated report generation with AI analysis, and comprehensive SCPI command abstraction.
 Author: Robin Mumm
 Maintainer: little-did-I-know

scpi_instrument_control-1.0.1/SCPI_Instrument_Control.egg-info/SOURCES.txt

@@ -0,0 +1,142 @@
+CHANGELOG.md
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+SCPI_Instrument_Control.egg-info/PKG-INFO
+SCPI_Instrument_Control.egg-info/SOURCES.txt
+SCPI_Instrument_Control.egg-info/dependency_links.txt
+SCPI_Instrument_Control.egg-info/entry_points.txt
+SCPI_Instrument_Control.egg-info/requires.txt
+SCPI_Instrument_Control.egg-info/top_level.txt
+docs/SDS800XHD_Series_ProgrammingGuide_EN11G.pdf
+docs/VISUAL_MEASUREMENTS.md
+docs/images/01_main_window.png
+docs/images/channel_controls.png
+docs/images/cursors.png
+docs/images/fft_analysis.png
+docs/images/main_window.png
+docs/images/measurements_panel.png
+docs/images/visual_measurements.png
+examples/README.md
+examples/advanced_analysis.py
+examples/basic_usage.py
+examples/batch_capture.py
+examples/continuous_capture.py
+examples/function_generator_basic.py
+examples/live_plot.py
+examples/measurements.py
+examples/probe_calibration_analysis.py
+examples/psu_advanced_features.py
+examples/psu_basic_control.py
+examples/psu_gui_test.py
+examples/psu_usb_connection.py
+examples/report_generation_example.py
+examples/simple_capture.py
+examples/trigger_based_capture.py
+examples/vector_graphics_xy_mode.py
+examples/waveform_capture.py
+resources/Test Equipment Wide.png
+resources/Test Equipment.icns
+resources/Test Equipment.ico
+resources/Test Equipment.png
+scpi_control/__init__.py
+scpi_control/analysis.py
+scpi_control/automation.py
+scpi_control/awg_models.py
+scpi_control/awg_output.py
+scpi_control/awg_scpi_commands.py
+scpi_control/channel.py
+scpi_control/exceptions.py
+scpi_control/function_generator.py
+scpi_control/math_channel.py
+scpi_control/measurement.py
+scpi_control/measurement_config.py
+scpi_control/models.py
+scpi_control/oscilloscope.py
+scpi_control/power_supply.py
+scpi_control/power_supply_output.py
+scpi_control/protocol_decode.py
+scpi_control/psu_data_logger.py
+scpi_control/psu_models.py
+scpi_control/psu_scpi_commands.py
+scpi_control/py.typed
+scpi_control/reference_waveform.py
+scpi_control/scpi_commands.py
+scpi_control/screen_capture.py
+scpi_control/trigger.py
+scpi_control/vector_graphics.py
+scpi_control/waveform.py
+scpi_control/connection/__init__.py
+scpi_control/connection/base.py
+scpi_control/connection/mock.py
+scpi_control/connection/socket.py
+scpi_control/connection/visa_connection.py
+scpi_control/gui/__init__.py
+scpi_control/gui/app.py
+scpi_control/gui/connection_manager.py
+scpi_control/gui/live_view_worker.py
+scpi_control/gui/main_window.py
+scpi_control/gui/vnc_window.py
+scpi_control/gui/waveform_capture_worker.py
+scpi_control/gui/utils/validators.py
+scpi_control/gui/widgets/__init__.py
+scpi_control/gui/widgets/channel_control.py
+scpi_control/gui/widgets/cursor_panel.py
+scpi_control/gui/widgets/error_dialog.py
+scpi_control/gui/widgets/fft_display.py
+scpi_control/gui/widgets/math_panel.py
+scpi_control/gui/widgets/measurement_marker.py
+scpi_control/gui/widgets/measurement_panel.py
+scpi_control/gui/widgets/protocol_decode_panel.py
+scpi_control/gui/widgets/psu_control.py
+scpi_control/gui/widgets/reference_panel.py
+scpi_control/gui/widgets/scope_web_view.py
+scpi_control/gui/widgets/terminal_widget.py
+scpi_control/gui/widgets/timebase_control.py
+scpi_control/gui/widgets/trigger_control.py
+scpi_control/gui/widgets/vector_graphics_panel.py
+scpi_control/gui/widgets/visual_measurement_panel.py
+scpi_control/gui/widgets/waveform_display.py
+scpi_control/gui/widgets/waveform_display_pg.py
+scpi_control/gui/widgets/measurement_markers/__init__.py
+scpi_control/gui/widgets/measurement_markers/frequency_marker.py
+scpi_control/gui/widgets/measurement_markers/timing_marker.py
+scpi_control/gui/widgets/measurement_markers/voltage_marker.py
+scpi_control/protocol_decoders/__init__.py
+scpi_control/protocol_decoders/i2c_decoder.py
+scpi_control/protocol_decoders/spi_decoder.py
+scpi_control/protocol_decoders/uart_decoder.py
+scpi_control/report_generator/__init__.py
+scpi_control/report_generator/app.py
+scpi_control/report_generator/main_window.py
+scpi_control/report_generator/generators/__init__.py
+scpi_control/report_generator/generators/base.py
+scpi_control/report_generator/generators/markdown_generator.py
+scpi_control/report_generator/generators/pdf_generator.py
+scpi_control/report_generator/llm/__init__.py
+scpi_control/report_generator/llm/analyzer.py
+scpi_control/report_generator/llm/client.py
+scpi_control/report_generator/llm/context_builder.py
+scpi_control/report_generator/llm/prompts.py
+scpi_control/report_generator/models/__init__.py
+scpi_control/report_generator/models/app_settings.py
+scpi_control/report_generator/models/criteria.py
+scpi_control/report_generator/models/plot_style.py
+scpi_control/report_generator/models/report_data.py
+scpi_control/report_generator/models/report_options.py
+scpi_control/report_generator/models/template.py
+scpi_control/report_generator/models/test_types.py
+scpi_control/report_generator/utils/__init__.py
+scpi_control/report_generator/utils/image_handler.py
+scpi_control/report_generator/utils/waveform_analyzer.py
+scpi_control/report_generator/utils/waveform_loader.py
+scpi_control/report_generator/widgets/__init__.py
+scpi_control/report_generator/widgets/ai_analysis_panel.py
+scpi_control/report_generator/widgets/chat_sidebar.py
+scpi_control/report_generator/widgets/llm_settings_dialog.py
+scpi_control/report_generator/widgets/metadata_panel.py
+scpi_control/report_generator/widgets/pdf_preview_dialog.py
+scpi_control/report_generator/widgets/report_options_dialog.py
+scpi_control/report_generator/widgets/template_manager_dialog.py
+siglent/__init__.py

scpi_instrument_control-1.0.1/SCPI_Instrument_Control.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+siglent-gui = scpi_control.gui.app:main
+siglent-report-generator = scpi_control.report_generator.app:main

scpi_instrument_control-1.0.1/SCPI_Instrument_Control.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+scpi_control
+siglent

{scpi_instrument_control-1.0.0 → scpi_instrument_control-1.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "SCPI-Instrument-Control"
-version = "1.0.0"
+version = "1.0.1"
 description = "Universal Python library for controlling SCPI-compatible test equipment via Ethernet/LAN. Supports oscilloscopes (Siglent SDS series, generic SCPI scopes), function generators/AWGs (Siglent SDG series, generic SCPI AWGs), and power supplies (Siglent SPD series, generic SCPI PSUs). Features include waveform capture, measurements, FFT analysis, PyQt6 GUI, automated report generation with AI analysis, and comprehensive SCPI command abstraction."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.8"
@@ -122,18 +122,19 @@ all = [
 ]
 
 [project.scripts]
-siglent-gui = "siglent.gui.app:main"
-siglent-report-generator = "siglent.report_generator.app:main"
+siglent-gui = "scpi_control.gui.app:main"
+siglent-report-generator = "scpi_control.report_generator.app:main"
 
 [tool.setuptools]
 include-package-data = true
 
 [tool.setuptools.package-data]
 siglent = ["py.typed"]
+scpi_control = ["py.typed"]
 
 [tool.setuptools.packages.find]
 where = ["."]
-include = ["siglent*"]
+include = ["siglent*", "scpi_control*"]
 
 [tool.black]
 line-length = 100
@@ -158,7 +159,7 @@ filterwarnings = [
 ]
 
 [tool.coverage.run]
-source = ["siglent"]
+source = ["siglent", "scpi_control"]
 omit = [
     "*/tests/*",
     "*/test_*.py",

scpi_instrument_control-1.0.1/scpi_control/__init__.py

@@ -0,0 +1,49 @@
+"""SCPI Instrument Control Package
+
+This package provides programmatic control for SCPI-compatible test equipment
+via Ethernet/LAN connection.
+
+Supported equipment:
+- Oscilloscopes (Siglent SDS series and SCPI-compatible models)
+- Function Generators / AWGs (Siglent SDG series and SCPI-compatible models)
+- Power Supplies (Siglent SPD series and SCPI-compatible models)
+
+For high-level automation and data collection, see the automation module:
+    from scpi_control.automation import DataCollector, TriggerWaitCollector
+
+For power supply control:
+    from scpi_control import PowerSupply
+
+For function generator control:
+    from scpi_control import FunctionGenerator
+
+For automated test report generation:
+    from scpi_control.report_generator import ReportGenerator
+"""
+
+__version__ = "1.0.1"
+
+from scpi_control.exceptions import CommandError, SiglentConnectionError, SiglentError, SiglentTimeoutError
+from scpi_control.oscilloscope import Oscilloscope
+
+# Power supply support (stable as of v0.5.0)
+from scpi_control.power_supply import PowerSupply
+from scpi_control.psu_data_logger import PSUDataLogger, TimedPSULogger
+
+# Function generator support (new in v0.6.0, stable in v1.0.0)
+from scpi_control.function_generator import FunctionGenerator
+
+__all__ = [
+    # Core features
+    "Oscilloscope",
+    "SiglentError",
+    "SiglentConnectionError",
+    "SiglentTimeoutError",
+    "CommandError",
+    # Power supply features
+    "PowerSupply",
+    "PSUDataLogger",
+    "TimedPSULogger",
+    # Function generator features
+    "FunctionGenerator",
+]

scpi_instrument_control-1.0.1/scpi_control/analysis.py

@@ -0,0 +1,401 @@
+"""Advanced analysis tools for waveform data."""
+
+import logging
+from dataclasses import dataclass
+from typing import Optional, Tuple
+
+import numpy as np
+from scipy import signal
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class FFTResult:
+    """Result of FFT analysis.
+
+    Attributes:
+        frequency: Frequency array (Hz)
+        magnitude: Magnitude array (linear or dB)
+        phase: Phase array (radians)
+        window: Window function used
+        sample_rate: Sample rate (Hz)
+        magnitude_db: Whether magnitude is in dB
+    """
+
+    frequency: np.ndarray
+    magnitude: np.ndarray
+    phase: np.ndarray
+    window: str
+    sample_rate: float
+    magnitude_db: bool = True
+
+    def get_peak_frequency(self, num_peaks: int = 1) -> list:
+        """Get the peak frequencies.
+
+        Args:
+            num_peaks: Number of peaks to find
+
+        Returns:
+            List of (frequency, magnitude) tuples
+        """
+        # Find peaks
+        peaks, _ = signal.find_peaks(self.magnitude, height=0)
+
+        # Sort by magnitude (descending)
+        if len(peaks) > 0:
+            peak_magnitudes = self.magnitude[peaks]
+            sorted_indices = np.argsort(peak_magnitudes)[::-1]
+            top_peaks = peaks[sorted_indices[:num_peaks]]
+
+            results = []
+            for peak_idx in top_peaks:
+                freq = self.frequency[peak_idx]
+                mag = self.magnitude[peak_idx]
+                results.append((freq, mag))
+
+            return results
+        else:
+            return []
+
+
+class FFTAnalyzer:
+    """FFT analyzer for frequency domain analysis of waveforms."""
+
+    WINDOW_FUNCTIONS = {
+        "rectangular": np.ones,
+        "hanning": np.hanning,
+        "hamming": np.hamming,
+        "blackman": np.blackman,
+        "bartlett": np.bartlett,
+        "flattop": signal.windows.flattop,
+    }
+
+    def __init__(self):
+        """Initialize FFT analyzer."""
+        logger.info("FFT analyzer initialized")
+
+    def compute_fft(self, waveform, window: str = "hanning", output_db: bool = True, detrend: bool = True) -> Optional[FFTResult]:
+        """Compute FFT of a waveform.
+
+        Args:
+            waveform: Input waveform
+            window: Window function name ('rectangular', 'hanning', 'hamming', 'blackman', 'bartlett', 'flattop')
+            output_db: If True, output magnitude in dB; otherwise linear
+            detrend: If True, remove DC component before FFT
+
+        Returns:
+            FFTResult or None if error
+        """
+        if waveform is None:
+            logger.warning("Cannot compute FFT on None waveform")
+            return None
+
+        try:
+            # Get voltage data
+            voltage = waveform.voltage
+            time = waveform.time
+
+            if len(voltage) < 2:
+                logger.warning("Waveform too short for FFT")
+                return None
+
+            # Calculate sample rate
+            dt = np.mean(np.diff(time))
+            sample_rate = 1.0 / dt
+
+            # Detrend if requested (remove DC component)
+            if detrend:
+                voltage = voltage - np.mean(voltage)
+
+            # Apply window function
+            if window.lower() in self.WINDOW_FUNCTIONS:
+                window_func = self.WINDOW_FUNCTIONS[window.lower()]
+                windowed_voltage = voltage * window_func(len(voltage))
+            else:
+                logger.warning(f"Unknown window function '{window}', using rectangular")
+                windowed_voltage = voltage
+
+            # Compute FFT
+            fft_result = np.fft.rfft(windowed_voltage)
+            frequencies = np.fft.rfftfreq(len(voltage), dt)
+
+            # Calculate magnitude and phase
+            magnitude_linear = np.abs(fft_result)
+            phase = np.angle(fft_result)
+
+            # Convert to dB if requested
+            if output_db:
+                # Avoid log(0) by using a small epsilon
+                epsilon = 1e-12
+                magnitude = 20 * np.log10(magnitude_linear + epsilon)
+            else:
+                magnitude = magnitude_linear
+
+            result = FFTResult(
+                frequency=frequencies,
+                magnitude=magnitude,
+                phase=phase,
+                window=window,
+                sample_rate=sample_rate,
+                magnitude_db=output_db,
+            )
+
+            logger.info(f"FFT computed: {len(frequencies)} frequency bins, " f"sample rate {sample_rate/1e6:.3f} MHz, window={window}")
+
+            return result
+
+        except Exception as e:
+            logger.error(f"FFT computation error: {e}")
+            return None
+
+    def compute_power_spectrum(self, waveform, window: str = "hanning", nperseg: Optional[int] = None) -> Optional[Tuple[np.ndarray, np.ndarray]]:
+        """Compute power spectral density using Welch's method.
+
+        Args:
+            waveform: Input waveform
+            window: Window function name
+            nperseg: Length of each segment (default: 256)
+
+        Returns:
+            Tuple of (frequencies, power_spectrum) or None if error
+        """
+        if waveform is None:
+            return None
+
+        try:
+            voltage = waveform.voltage
+            time = waveform.time
+            dt = np.mean(np.diff(time))
+            sample_rate = 1.0 / dt
+
+            if nperseg is None:
+                nperseg = min(256, len(voltage) // 4)
+
+            # Compute power spectral density using Welch's method
+            frequencies, psd = signal.welch(voltage, fs=sample_rate, window=window, nperseg=nperseg, scaling="density")
+
+            logger.info(f"Power spectrum computed using Welch's method")
+
+            return frequencies, psd
+
+        except Exception as e:
+            logger.error(f"Power spectrum computation error: {e}")
+            return None
+
+    def compute_spectrogram(self, waveform, window: str = "hanning", nperseg: Optional[int] = None) -> Optional[Tuple[np.ndarray, np.ndarray, np.ndarray]]:
+        """Compute spectrogram (time-frequency representation).
+
+        Args:
+            waveform: Input waveform
+            window: Window function name
+            nperseg: Length of each segment (default: 256)
+
+        Returns:
+            Tuple of (frequencies, times, spectrogram) or None if error
+        """
+        if waveform is None:
+            return None
+
+        try:
+            voltage = waveform.voltage
+            time = waveform.time
+            dt = np.mean(np.diff(time))
+            sample_rate = 1.0 / dt
+
+            if nperseg is None:
+                nperseg = min(256, len(voltage) // 4)
+
+            # Compute spectrogram
+            frequencies, times, Sxx = signal.spectrogram(voltage, fs=sample_rate, window=window, nperseg=nperseg)
+
+            logger.info(f"Spectrogram computed: {len(frequencies)}x{len(times)} matrix")
+
+            return frequencies, times, Sxx
+
+        except Exception as e:
+            logger.error(f"Spectrogram computation error: {e}")
+            return None
+
+    def apply_bandpass_filter(self, waveform, lowcut: float, highcut: float, order: int = 5):
+        """Apply bandpass filter to waveform.
+
+        Args:
+            waveform: Input waveform
+            lowcut: Low frequency cutoff (Hz)
+            highcut: High frequency cutoff (Hz)
+            order: Filter order
+
+        Returns:
+            Filtered waveform or None if error
+        """
+        if waveform is None:
+            return None
+
+        try:
+            voltage = waveform.voltage
+            time = waveform.time
+            dt = np.mean(np.diff(time))
+            sample_rate = 1.0 / dt
+
+            # Design Butterworth bandpass filter
+            nyquist = sample_rate / 2.0
+            low = lowcut / nyquist
+            high = highcut / nyquist
+
+            if low <= 0 or high >= 1:
+                logger.error("Filter frequencies out of valid range")
+                return None
+
+            sos = signal.butter(order, [low, high], btype="band", output="sos")
+
+            # Apply filter
+            filtered_voltage = signal.sosfilt(sos, voltage)
+
+            # Create filtered waveform
+            result = type(waveform)(time=time, voltage=filtered_voltage, channel=f"{waveform.channel}_FILTERED")
+
+            logger.info(f"Bandpass filter applied: {lowcut:.2f}-{highcut:.2f} Hz, order={order}")
+
+            return result
+
+        except Exception as e:
+            logger.error(f"Bandpass filter error: {e}")
+            return None
+
+    def apply_lowpass_filter(self, waveform, cutoff: float, order: int = 5):
+        """Apply lowpass filter to waveform.
+
+        Args:
+            waveform: Input waveform
+            cutoff: Cutoff frequency (Hz)
+            order: Filter order
+
+        Returns:
+            Filtered waveform or None if error
+        """
+        if waveform is None:
+            return None
+
+        try:
+            voltage = waveform.voltage
+            time = waveform.time
+            dt = np.mean(np.diff(time))
+            sample_rate = 1.0 / dt
+
+            # Design Butterworth lowpass filter
+            nyquist = sample_rate / 2.0
+            normal_cutoff = cutoff / nyquist
+
+            if normal_cutoff <= 0 or normal_cutoff >= 1:
+                logger.error("Filter cutoff out of valid range")
+                return None
+
+            sos = signal.butter(order, normal_cutoff, btype="low", output="sos")
+
+            # Apply filter
+            filtered_voltage = signal.sosfilt(sos, voltage)
+
+            # Create filtered waveform
+            result = type(waveform)(time=time, voltage=filtered_voltage, channel=f"{waveform.channel}_FILTERED")
+
+            logger.info(f"Lowpass filter applied: {cutoff:.2f} Hz, order={order}")
+
+            return result
+
+        except Exception as e:
+            logger.error(f"Lowpass filter error: {e}")
+            return None
+
+    def apply_highpass_filter(self, waveform, cutoff: float, order: int = 5):
+        """Apply highpass filter to waveform.
+
+        Args:
+            waveform: Input waveform
+            cutoff: Cutoff frequency (Hz)
+            order: Filter order
+
+        Returns:
+            Filtered waveform or None if error
+        """
+        if waveform is None:
+            return None
+
+        try:
+            voltage = waveform.voltage
+            time = waveform.time
+            dt = np.mean(np.diff(time))
+            sample_rate = 1.0 / dt
+
+            # Design Butterworth highpass filter
+            nyquist = sample_rate / 2.0
+            normal_cutoff = cutoff / nyquist
+
+            if normal_cutoff <= 0 or normal_cutoff >= 1:
+                logger.error("Filter cutoff out of valid range")
+                return None
+
+            sos = signal.butter(order, normal_cutoff, btype="high", output="sos")
+
+            # Apply filter
+            filtered_voltage = signal.sosfilt(sos, voltage)
+
+            # Create filtered waveform
+            result = type(waveform)(time=time, voltage=filtered_voltage, channel=f"{waveform.channel}_FILTERED")
+
+            logger.info(f"Highpass filter applied: {cutoff:.2f} Hz, order={order}")
+
+            return result
+
+        except Exception as e:
+            logger.error(f"Highpass filter error: {e}")
+            return None
+
+    @staticmethod
+    def calculate_thd(fft_result: FFTResult, fundamental_freq: float, num_harmonics: int = 5) -> Optional[float]:
+        """Calculate Total Harmonic Distortion (THD).
+
+        Args:
+            fft_result: FFT result
+            fundamental_freq: Fundamental frequency (Hz)
+            num_harmonics: Number of harmonics to include
+
+        Returns:
+            THD in percent or None if error
+        """
+        try:
+            # Find fundamental frequency bin
+            freq_resolution = fft_result.frequency[1] - fft_result.frequency[0]
+            fund_idx = int(round(fundamental_freq / freq_resolution))
+
+            if fund_idx >= len(fft_result.magnitude):
+                logger.error("Fundamental frequency out of range")
+                return None
+
+            # Get fundamental magnitude (linear)
+            if fft_result.magnitude_db:
+                fund_mag = 10 ** (fft_result.magnitude[fund_idx] / 20.0)
+            else:
+                fund_mag = fft_result.magnitude[fund_idx]
+
+            # Calculate harmonic magnitudes
+            harmonic_power = 0.0
+            for n in range(2, num_harmonics + 2):
+                harmonic_idx = n * fund_idx
+                if harmonic_idx < len(fft_result.magnitude):
+                    if fft_result.magnitude_db:
+                        harm_mag = 10 ** (fft_result.magnitude[harmonic_idx] / 20.0)
+                    else:
+                        harm_mag = fft_result.magnitude[harmonic_idx]
+                    harmonic_power += harm_mag**2
+
+            # Calculate THD
+            thd = 100.0 * np.sqrt(harmonic_power) / fund_mag
+
+            logger.info(f"THD calculated: {thd:.2f}% (fundamental={fundamental_freq:.2f} Hz)")
+
+            return thd
+
+        except Exception as e:
+            logger.error(f"THD calculation error: {e}")
+            return None