S-0270 - Supplemental 270 - SDR Automation with Python

Author: Patrick Luan de Mattos
Category Path: sdr-hacking
Audience Level: Intermediate
Generated at: 2026-04-03T16:05:05.730Z

Supplemental Chapter: SDR Automation with Python

270: SDR Automation with Python

1) Position of this Supplemental Chapter in the Advanced SDR Roadmap

This supplemental chapter builds upon a foundational understanding of Software Defined Radio (SDR) principles, basic signal processing, and introductory Python programming. It is positioned within the advanced SDR roadmap after core concepts like modulation/demodulation, spectrum analysis, and initial exposure to SDR frameworks such as GNU Radio. This chapter serves as a bridge to more complex SDR applications, enabling efficient data acquisition, sophisticated offline analysis, and robust experimental design.

2) Deep Conceptual Explanation

The increasing complexity and data volume in modern radio frequency (RF) and SDR applications necessitate efficient and repeatable workflows. Manual operation of SDR hardware for data capture, signal analysis, and experimentation is often time-consuming, prone to human error, and limits the scalability of research and development.

SDR Automation with Python addresses these challenges by leveraging the power of Python, a versatile and widely adopted programming language, to control SDR hardware, orchestrate signal processing tasks, and manage experimental parameters. This approach allows for:

• IQ Capture Automation: Programmatically initiating and terminating I/Q (In-phase and Quadrature) data captures from SDR devices. This includes defining capture duration, sample rate, center frequency, gain settings, and other critical parameters. Automated captures are essential for collecting large datasets for machine learning, signal intelligence (SIGINT) analysis, or long-term monitoring.
• Offline DSP Workflows: Building flexible and modular Digital Signal Processing (DSP) pipelines that can be executed on captured I/Q data without requiring the SDR hardware to be actively transmitting or receiving. This allows for rapid prototyping of new algorithms, in-depth analysis of complex signals, and reproduction of results. Python's rich ecosystem of scientific libraries (NumPy, SciPy, Pandas) excels in this domain.
• Repeatable Experiment Design: Encapsulating experimental setups, parameter sweeps, and data collection procedures within Python scripts. This ensures that experiments can be precisely replicated, facilitating scientific rigor, debugging, and collaborative research. By automating the entire experimental process, researchers can efficiently explore parameter spaces and validate hypotheses.

The core idea is to treat the SDR as a programmable instrument, akin to a digital oscilloscope or signal generator, but with the added flexibility of software-defined signal manipulation. Python acts as the control plane, dictating the SDR's behavior and processing its output.

3) Architecture and Signal Reasoning

The typical architecture for SDR automation with Python involves several key components:

• SDR Hardware: The physical radio device (e.g., RTL-SDR, HackRF, USRP) capable of digitizing RF signals into I/Q data.
• SDR Driver/API: Software libraries (often provided by the hardware manufacturer or open-source projects like pyrtlsdr, SoapySDR) that provide a Python interface to control the SDR hardware.
• Python Control Script: The central piece of the automation, written in Python, that orchestrates the entire workflow. This script interacts with the SDR API, manages data flow, and calls DSP functions.
• DSP Libraries: Python libraries like NumPy for numerical operations, SciPy for scientific computing (including signal processing functions), and potentially specialized libraries for specific tasks (e.g., scikit-dsp-comm for communications DSP).
• Data Storage: Mechanisms for saving captured I/Q data (e.g., .npy files, .dat files) and analysis results.

Signal Reasoning:

The fundamental unit of data in SDR is I/Q data. This represents a complex baseband signal, where 'I' is the in-phase component and 'Q' is the quadrature component. Each sample is a pair of floating-point or integer values.

Consider a simple sine wave at a specific frequency. When digitized by an SDR, this analog signal is sampled at a certain rate ($F_s$). The SDR outputs discrete I/Q samples.

Visual Example: I/Q Representation of a Simple Tone

Let's imagine a pure sine wave at a frequency $f_0$ relative to the SDR's center frequency $F_c$. After mixing down to baseband, this signal can be represented as:

$s(t) = A \cos(2\pi f_0 t + \phi)$

The I/Q samples represent the real and imaginary parts of this complex signal at discrete time intervals $t = n/F_s$:

$I_n = A \cos(2\pi f_0 \frac{n}{F_s} + \phi)$
$Q_n = -A \sin(2\pi f_0 \frac{n}{F_s} + \phi)$ (This is a common convention, though variations exist)

In Python, this would be represented as an array of complex numbers, where each complex number is I + jQ.

Bit Pattern / Byte Layout Example (Conceptual for a simple IQ stream):

If an SDR outputs 16-bit signed integers for I and Q:

[ I_sample_byte1 | I_sample_byte2 | Q_sample_byte1 | Q_sample_byte2 ]

For a sequence of samples:

[ I_sample1_b1 | I_sample1_b2 | Q_sample1_b1 | Q_sample1_b2 | I_sample2_b1 | I_sample2_b2 | Q_sample2_b1 | Q_sample2_b2 | ... ]

This raw byte stream needs to be interpreted by Python libraries into numerical arrays for processing.

Flow Illustration:

graph TD
    A[SDR Hardware] --> B(SDR Driver/API);
    B --> C{Python Control Script};
    C --> D[Data Capture Command];
    D --> A;
    A --> E[Raw I/Q Data Stream];
    E --> B;
    B --> F[Parsed I/Q Data (NumPy Array)];
    F --> C;
    C --> G[DSP Operations (SciPy, etc.)];
    G --> H[Analysis Results];
    C --> I[Save Data/Results];
    I --> J[File Storage (.npy, .csv)];

4) Python Examples

This section demonstrates how Python can be used to automate I/Q capture and perform basic offline DSP.

Example 1: Basic I/Q Capture with pyrtlsdr

This example assumes you have an RTL-SDR dongle and the pyrtlsdr library installed (pip install pyrtlsdr numpy).

import numpy as np
from rtlsdr import RtlSdr
import time

# --- Configuration ---
SAMPLE_RATE = 2.4e6  # Hz
CENTER_FREQ = 100e6  # Hz (e.g., FM radio band)
GAIN = 'auto'        # 'auto' or a specific gain setting
NUM_SAMPLES = 2**16  # Number of samples to capture
CAPTURE_DURATION = 5 # seconds (if not using NUM_SAMPLES to limit)
OUTPUT_FILENAME = "iq_capture.npy"

# --- Initialize SDR ---
try:
    sdr = RtlSdr()
    print("SDR initialized successfully.")
except Exception as e:
    print(f"Error initializing SDR: {e}")
    exit()

# --- Configure SDR ---
sdr.sample_rate = SAMPLE_RATE
sdr.center_freq = CENTER_FREQ
sdr.gain = GAIN
print(f"SDR configured: Sample Rate={sdr.sample_rate/1e6} MHz, Center Freq={sdr.center_freq/1e6} MHz, Gain={sdr.gain}")

# --- Capture I/Q Data ---
print(f"Starting I/Q capture for {NUM_SAMPLES} samples...")
try:
    # Read samples. `read_samples` will block until the requested number of samples is acquired.
    # Alternatively, use `read_async` for non-blocking capture.
    iq_data = sdr.read_samples(NUM_SAMPLES)
    print(f"Capture complete. Acquired {len(iq_data)} samples.")

    # --- Process and Save Data ---
    # I/Q data from pyrtlsdr is usually in complex64 format (float32 for I and Q)
    # You can perform DSP here or save it for later.

    # Save raw I/Q data
    np.save(OUTPUT_FILENAME, iq_data)
    print(f"I/Q data saved to {OUTPUT_FILENAME}")

except Exception as e:
    print(f"Error during capture: {e}")

finally:
    # --- Clean up SDR ---
    sdr.close()
    print("SDR closed.")

Explanation:

• We import numpy for numerical array handling and RtlSdr from pyrtlsdr.
• Configuration parameters like SAMPLE_RATE, CENTER_FREQ, and GAIN are defined.
• An RtlSdr object is instantiated.
• The SDR's parameters are set.
• sdr.read_samples(NUM_SAMPLES) captures the specified number of I/Q samples. This is a blocking call.
• The captured iq_data is a NumPy array of complex numbers.
• np.save() stores the NumPy array to a file.
• A finally block ensures the SDR is closed even if errors occur.

Example 2: Offline DSP Workflow (Spectrum Analysis)

This example loads the previously captured I/Q data and performs a Fast Fourier Transform (FFT) to visualize the spectrum.

import numpy as np
import matplotlib.pyplot as plt

# --- Configuration ---
INPUT_FILENAME = "iq_capture.npy"
FFT_SIZE = 1024 # Number of points for FFT
SAMPLE_RATE = 2.4e6 # Must match the capture sample rate

# --- Load I/Q Data ---
try:
    iq_data = np.load(INPUT_FILENAME)
    print(f"Loaded {len(iq_data)} samples from {INPUT_FILENAME}")
except FileNotFoundError:
    print(f"Error: File not found at {INPUT_FILENAME}")
    exit()
except Exception as e:
    print(f"Error loading file: {e}")
    exit()

# --- Offline DSP: FFT for Spectrum Analysis ---
print(f"Performing FFT with size {FFT_SIZE}...")

# To perform FFT, we can take chunks of the IQ data.
# We'll use a sliding window approach for smoother results.
# For simplicity here, we'll just take the first chunk.
# A more robust approach would average multiple FFTs.

if len(iq_data) < FFT_SIZE:
    print(f"Warning: Not enough data for FFT of size {FFT_SIZE}. Using available data.")
    fft_data = iq_data
else:
    fft_data = iq_data[:FFT_SIZE]

# Compute the FFT
# np.fft.fft computes the Discrete Fourier Transform
# We take the absolute value and normalize for magnitude
spectrum = np.abs(np.fft.fft(fft_data))

# The FFT output is symmetric for real inputs. We usually only look at the first half.
spectrum = spectrum[:FFT_SIZE // 2]

# Create the frequency axis
# The frequencies range from -SAMPLE_RATE/2 to +SAMPLE_RATE/2
# For the first half, it's 0 to SAMPLE_RATE/2
frequencies = np.linspace(0, SAMPLE_RATE / 2, FFT_SIZE // 2)

# --- Plotting ---
plt.figure(figsize=(10, 6))
plt.plot(frequencies / 1e6, 20 * np.log10(spectrum / np.max(spectrum))) # dB scale, normalized
plt.title("Spectrum Analysis (Offline DSP)")
plt.xlabel("Frequency (MHz)")
plt.ylabel("Magnitude (dB)")
plt.grid(True)
plt.show()

print("Spectrum analysis complete.")

Explanation:

• We load the I/Q data saved in the previous step using np.load().
• We define FFT_SIZE for the FFT computation.
• We extract a chunk of data for the FFT. In a real application, you'd likely average FFTs from multiple segments or use windowing functions (e.g., np.hanning) to reduce spectral leakage.
• np.fft.fft() computes the FFT.
• We take the magnitude (np.abs()) and convert it to decibels (dB) for better visualization.
• We create a frequency axis using np.linspace corresponding to the FFT output.
• matplotlib.pyplot is used to plot the spectrum.

5) GNU Radio Examples

GNU Radio is a powerful open-source toolkit for building software radio applications. While this chapter focuses on Python automation, it's important to note how Python integrates with GNU Radio, particularly for creating reusable blocks or controlling complex flowgraphs.

Conceptual GNU Radio Flowgraph for IQ Capture:

graph LR
    A[SDR Source Block (e.g., Osmocom Source)] --> B(Throttle Block);
    B --> C(File Sink Block);
    C --> D[File Storage (.dat, .iq)];
    E[Python Script] --> F{GNU Radio Companion (GRC)};
    F --> G[Generated C++ Code];
    G --> H[Compiled Executable];
    H --> I[Runs Flowgraph];

Python can be used in several ways with GNU Radio:

1. Python Blocks: Create custom DSP blocks written entirely in Python. These are useful for rapid prototyping of algorithms.
2. Python Flowgraph Control: Use the gr.top_block API in Python to programmatically create, start, stop, and modify GNU Radio flowgraphs. This is key for automation.
3. GRC Generated Python Scripts: GNU Radio Companion (GRC) can generate Python scripts that represent the flowgraph. These scripts can then be executed or further modified.

Example: Programmatic Control of a GNU Radio Flowgraph (Conceptual Python Script)

This Python script would generate and run a GNU Radio flowgraph to capture I/Q data. This requires a basic understanding of GNU Radio's Python API.

#!/usr/bin/env python3

import sys
import numpy as np
import gnuradio as gr
from gnuradio import blocks
from gnuradio import uhd # Example for USRP, replace with rtlsdr if needed
from gnuradio import gr

# --- Configuration ---
SAMPLE_RATE = 2.4e6  # Hz
CENTER_FREQ = 100e6  # Hz
GAIN = 30            # dB
NUM_SAMPLES = 2**16  # Number of samples to capture
OUTPUT_FILENAME = "gr_iq_capture.dat"

class MyIQCapture(gr.top_block):
    def __init__(self, sample_rate, center_freq, gain, num_samples, output_filename):
        gr.top_block.__init__(self, "IQ Capture Flowgraph")

        self.sample_rate = sample_rate
        self.center_freq = center_freq
        self.gain = gain
        self.num_samples = num_samples
        self.output_filename = output_filename

        # --- Blocks ---

        # SDR Source (Example: UHD for USRP, replace with appropriate block for your SDR)
        # For RTL-SDR, you'd typically use 'osmosdr.source' if installed with gr-osmosdr
        # Example using osmosdr.source:
        # from gnuradio import osmosdr
        # self.blocks_source_0 = osmosdr.source(args="numchan=" + str(1) + " ")
        # self.blocks_source_0.set_sample_rate(sample_rate)
        # self.blocks_source_0.set_center_freq(center_freq, 0)
        # self.blocks_source_0.set_gain(gain, 0)
        # self.blocks_source_0.set_antenna(antenna, 0) # If applicable

        # Placeholder for a generic source block - replace with your actual SDR block
        # For demonstration, let's simulate data if no SDR is available.
        # In a real scenario, you would configure your actual SDR source here.
        print("NOTE: Using simulated data. Replace with your actual SDR source block (e.g., osmosdr.source).")
        self.blocks_vector_source_0 = blocks.vector_source_c(
            np.random.normal(0, 1, num_samples) + 1j*np.random.normal(0, 1, num_samples),
            True, # repeat
            1,    # dimensions
            []    # vector
        )
        self.blocks_vector_source_0.set_sample_rate(sample_rate)


        # File Sink
        # The 'gr.sizeof_gr_complex' specifies that we are writing complex numbers (I/Q)
        self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_gr_complex, output_filename)
        self.blocks_file_sink_0.set_ ஏற்ப (False) # Don't append to file if it exists

        # Optional: Throttle to limit CPU usage if not using real hardware source
        # self.blocks_throttle_0 = blocks.throttle(gr.Sample.new(gr.sizeof_gr_complex), sample_rate)


        # --- Connections ---
        # Connect the SDR source to the File Sink
        # self.connect((self.blocks_source_0, 0), (self.blocks_throttle_0, 0)) # if using throttle
        # self.connect((self.blocks_throttle_0, 0), (self.blocks_file_sink_0, 0)) # if using throttle

        # Connect simulated source to file sink
        self.connect((self.blocks_vector_source_0, 0), (self.blocks_file_sink_0, 0))

    def stop(self):
        gr.top_block.stop(self)

    def start(self):
        gr.top_block.start(self)

def main():
    tb = MyIQCapture(SAMPLE_RATE, CENTER_FREQ, GAIN, NUM_SAMPLES, OUTPUT_FILENAME)
    print("Starting GNU Radio flowgraph for I/Q capture...")
    tb.start()

    # Run for a specific duration or until a condition is met
    # For a fixed number of samples, the vector source will repeat.
    # For a real SDR source, you might want a time-based stop.
    # Example for time-based stop:
    # import threading
    # stop_thread = threading.Thread(target=lambda: tb.stop())
    # timer = threading.Timer(CAPTURE_DURATION, stop_thread.start)
    # timer.start()

    # To stop after NUM_SAMPLES from a real source, you'd need to monitor samples received
    # or use a different stopping mechanism. For simulated data, it runs continuously.

    # For this example, let's just run for a bit and then stop.
    # In a real scenario, you would manage the execution duration more carefully.
    try:
        # This part is tricky for a simple simulation.
        # For a real SDR source, you'd let it run and then call tb.stop()
        # based on some external trigger or time.
        # For this simulation, we'll just let it run briefly.
        print("Running flowgraph (simulated data). Press Ctrl+C to stop.")
        tb.wait() # Blocks until the flowgraph stops
    except KeyboardInterrupt:
        print("Stopping flowgraph...")
        tb.stop()
        tb.wait()
        print("Flowgraph stopped.")

if __name__ == '__main__':
    main()

Explanation:

• We import necessary GNU Radio modules (blocks, uhd, gr).
• We define a class MyIQCapture that inherits from gr.top_block.
• Inside __init__, we instantiate GNU Radio blocks:
  • An SDR source block (e.g., osmosdr.source for RTL-SDR or uhd.usrp_source for USRP). Note: The example uses a blocks.vector_source_c for simulation as setting up real SDRs programmatically can be complex and hardware-dependent.
  • A blocks.file_sink to write the I/Q data to a file.
• We connect these blocks to define the data flow.
• The main function creates an instance of MyIQCapture, starts it, and then waits for it to finish (or until interrupted).

This approach allows for complex, multi-stage SDR workflows to be defined and executed entirely within Python, leveraging GNU Radio's optimized C++ backend for performance.

6) Visual Examples

ASCII Signal Diagram: Conceptual I/Q Samples

This ASCII diagram represents a sequence of I/Q samples over time. Imagine the 'I' axis as horizontal and 'Q' as vertical. Each point is a sample.

       ^ Q
       |
       |       o (Sample 3: I=low, Q=high)
       |
       | o (Sample 2: I=low, Q=low)
-------+------------------------> I
       | o (Sample 1: I=high, Q=low)
       |
       |       o (Sample 4: I=high, Q=high)
       |

• Sample 1: Positive I, Negative Q (e.g., 4th Quadrant)
• Sample 2: Negative I, Negative Q (e.g., 3rd Quadrant)
• Sample 3: Negative I, Positive Q (e.g., 2nd Quadrant)
• Sample 4: Positive I, Positive Q (e.g., 1st Quadrant)

The sequence of these points traces out the constellation diagram of a modulated signal or the phase/amplitude changes of a continuous wave.

Bit Pattern Example: 8-bit IQ Sample

If an SDR outputs 8-bit signed integers for I and Q:

• I Sample: [sign_bit][bit_6][bit_5][bit_4][bit_3][bit_2][bit_1][bit_0]
• Q Sample: [sign_bit][bit_6][bit_5][bit_4][bit_3][bit_2][bit_1][bit_0]

A single complex sample would be represented as 16 bits:

[ I_byte | Q_byte ]

Example Byte Layout (Two 8-bit Samples):

Byte 0: I_sample_1 (7 bits data + 1 sign bit)
Byte 1: Q_sample_1 (7 bits data + 1 sign bit)
Byte 2: I_sample_2 (7 bits data + 1 sign bit)
Byte 3: Q_sample_2 (7 bits data + 1 sign bit)
... and so on.

This raw byte data needs to be interpreted. For instance, a positive I value might be represented as 0 followed by the binary magnitude, while a negative value would be 1 followed by the magnitude (or two's complement). Python libraries handle this interpretation.

Flow Illustration: Repeatable Experiment Design

This illustration shows how Python scripts can automate a parameter sweep for an experiment.

graph TD
    A[Experiment Design Script (Python)] --> B{Parameter Sweep Loop};
    B --> C[Set Center Frequency];
    B --> D[Set Sample Rate];
    B --> E[Set Gain];
    C --> F[Automated IQ Capture];
    D --> F;
    E --> F;
    F --> G[Save Raw IQ Data];
    G --> H[Offline Analysis Script (Python)];
    H --> I[Compute Metrics (e.g., SNR, BER)];
    I --> J[Store Results];
    J --> K{Experiment Summary Report};
    B --> L{Next Parameter Combination};
    L --> B;
    K --> M[Conclusion/Visualization];

Here, the "Experiment Design Script" controls the "Automated IQ Capture" by iterating through various CENTER_FREQ, SAMPLE_RATE, and GAIN values. The captured data is then processed by an "Offline Analysis Script" to extract meaningful metrics, ensuring each experimental run is identical in its procedure, thus making the design repeatable.

7) Defensive and Offensive Implications and Troubleshooting

Defensive Implications:

• Security Auditing: Automated I/Q capture can be used in a controlled environment to record radio traffic for later analysis to identify unauthorized transmissions, rogue devices, or potential jamming attempts. This is a crucial aspect of RF security auditing.
• Vulnerability Discovery: By automating the process of probing a radio system with different signal types or parameters and analyzing the responses, developers can uncover vulnerabilities in communication protocols or hardware implementations.
• Anomaly Detection: Long-term, automated monitoring of the RF spectrum can establish a baseline of normal activity. Deviations from this baseline (anomalies) can be flagged, potentially indicating malicious activity.
• Reproducible Security Testing: Automation ensures that security tests are performed consistently, allowing for reliable identification of security weaknesses.

Offensive Implications (Conceptual/Shielded Lab):

• Signal Intelligence (SIGINT): In a strictly controlled and authorized context, automated capture and analysis can be used to gather intelligence on communication systems. This is a complex field requiring specialized knowledge and tools.
• Reconnaissance: Automated scanning of an RF environment to identify active devices, their frequencies, and signal characteristics can be a precursor to other offensive actions.
• Exploitation of Vulnerabilities: Once a vulnerability is discovered through automated testing, the same automation tools could potentially be used to craft specific signals to exploit that vulnerability.

Troubleshooting Common Issues:

• SDR Not Detected:
  • Problem: Python script cannot find the SDR device.
  • Troubleshooting:
    • Ensure the SDR is properly connected via USB.
    • Verify that the necessary drivers are installed and recognized by the operating system.
    • Check if other applications are already using the SDR.
    • Try a different USB port or cable.
    • For GNU Radio, ensure the correct SDR support libraries (e.g., gr-osmosdr, gr-uhd) are installed.
• Capture Errors / Corrupted Data:
  • Problem: read_samples fails, or captured data is nonsensical.
  • Troubleshooting:
    • Sample Rate Mismatch: Ensure the SAMPLE_RATE in your script matches the capabilities of the SDR and is not too high for the USB bus or CPU to handle.
    • Gain Settings: Extreme gain settings can lead to saturation or insufficient signal. Try adjusting GAIN (e.g., 'auto' or specific dB values).
    • Buffer Issues: For high sample rates, ensure sufficient buffer sizes are configured if using asynchronous methods.
    • CPU Overload: If the CPU cannot process the incoming data fast enough, it can lead to drops. Consider reducing SAMPLE_RATE, NUM_SAMPLES, or using a more efficient processing method (e.g., C++ blocks in GNU Radio).
    • USB Bandwidth: On some systems, too many USB devices or a low-speed USB port can limit throughput.
• DSP Issues (e.g., Incorrect Spectrum):
  • Problem: FFT output doesn't look as expected.
  • Troubleshooting:
    • Frequency Offset: The SDR's local oscillator might have a slight frequency offset. This is common and can be corrected in software.
    • Sample Rate Accuracy: Ensure the SAMPLE_RATE used for DSP exactly matches the SDR's capture rate.
    • Windowing: For accurate spectral analysis, especially with non-periodic signals, apply windowing functions (e.g., Hamming, Hanning, Blackman) before the FFT to reduce spectral leakage.
    • FFT Size: An appropriate FFT_SIZE is crucial for frequency resolution.
    • Normalization: Ensure consistent normalization when comparing spectra.
• GNU Radio Flowgraph Not Running:
  • Problem: Python script using GNU Radio API fails to start or run.
  • Troubleshooting:
    • Dependencies: Ensure all necessary GNU Radio modules and their dependencies are installed correctly.
    • SDR Block Configuration: Double-check the arguments and parameters for your specific SDR source block.
    • Python Environment: Make sure you are running the script in the correct Python environment where GNU Radio is installed.
    • Flowgraph Errors: Examine the output logs from GNU Radio for specific error messages.

8) Summary

SDR automation with Python unlocks a powerful paradigm for efficient and repeatable RF experimentation and analysis. By programmatically controlling SDR hardware, we can automate I/Q data capture for large-scale data collection. This captured data can then be fed into sophisticated offline Digital Signal Processing (DSP) workflows, leveraging Python's extensive scientific libraries. This approach is fundamental for designing repeatable experiments, enabling rigorous scientific investigation and robust RF security testing. Whether using direct Python libraries like pyrtlsdr or orchestrating complex flowgraphs with GNU Radio's Python API, automation significantly enhances productivity, accuracy, and the depth of insights obtainable from SDR systems. This chapter has provided a conceptual foundation, practical Python examples for I/Q capture and offline analysis, and touched upon GNU Radio integration, equipping intermediate SDR practitioners with the skills to automate their RF workflows.

This chapter is educational, lab-oriented, and constrained to lawful, defensive, and controlled research contexts.