PySDR

https://pysdr.org/content/
Admin
PySDR provides comprehensive educational content and guides on Software Defined Radio (SDR) and...
Tokens:149,122
Snippets:1,261
Trust Score:8.4
Update:3 months ago
Show doc for...
Tokens:
Raw
### PyQt Application Initialization and Execution

Source: https://pysdr.org/content/pyqt.html

This snippet shows the standard PyQt application setup, including creating the QApplication instance, initializing the main window, showing the window, and starting the event loop. It also includes signal handling for graceful shutdown.

```Python
app = QApplication([])
window = MainWindow()
window.show() # Windows are hidden by default
signal.signal(signal.SIGINT, signal.SIG_DFL) # this lets control-C actually close the app
app.exec() # Start the event loop
```

--------------------------------

### PyQt Main Window Setup

Source: https://pysdr.org/content/pyqt.html

This code defines the main application window for the spectrum analyzer. It sets up the window title, size, layout, and initializes a QThread for SDR operations. Ensure PyQt5 and pyqtgraph are installed.

```python
# Subclass QMainWindow to customize your application's main window
class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()

        self.setWindowTitle("The PySDR Spectrum Analyzer")
        self.setFixedSize(QSize(1500, 1000)) # window size, starting size should fit on 1920 x 1080

        self.spectrogram_min = 0
        self.spectrogram_max = 0

        layout = QGridLayout() # overall layout

        # Initialize worker and thread
        self.sdr_thread = QThread()
        self.sdr_thread.setObjectName('SDR_Thread') # so we can see it in htop, note you have to hit F2 -> Display options -> Show custom thread names
        worker = SDRWorker()
        worker.moveToThread(self.sdr_thread)

        # Time plot
        time_plot = pg.PlotWidget(labels={'left': 'Amplitude', 'bottom': 'Time [microseconds]'})
        time_plot.setMouseEnabled(x=False, y=True)
        time_plot.setYRange(-1.1, 1.1)
        time_plot_curve_i = time_plot.plot([])
        time_plot_curve_q = time_plot.plot([])
        layout.addWidget(time_plot, 1, 0)

        # Time plot auto range buttons
        time_plot_auto_range_layout = QVBoxLayout()
        layout.addLayout(time_plot_auto_range_layout, 1, 1)
        auto_range_button = QPushButton('Auto Range')
        auto_range_button.clicked.connect(lambda : time_plot.autoRange()) # lambda just means its an unnamed function
        time_plot_auto_range_layout.addWidget(auto_range_button)
        auto_range_button2 = QPushButton('-1 to +1
(ADC limits)')
        auto_range_button2.clicked.connect(lambda : time_plot.setYRange(-1.1, 1.1))
        time_plot_auto_range_layout.addWidget(auto_range_button2)

        # Freq plot
        freq_plot = pg.PlotWidget(labels={'left': 'PSD', 'bottom': 'Frequency [MHz]'})
        freq_plot.setMouseEnabled(x=False, y=True)
        freq_plot_curve = freq_plot.plot([])
        freq_plot.setXRange(center_freq/1e6 - sample_rate/2e6, center_freq/1e6 + sample_rate/2e6)
        freq_plot.setYRange(-30, 20)
        layout.addWidget(freq_plot, 2, 0)

        # Freq auto range button
        auto_range_button = QPushButton('Auto Range')
        auto_range_button.clicked.connect(lambda : freq_plot.autoRange()) # lambda just means its an unnamed function
        layout.addWidget(auto_range_button, 2, 1)

        # Layout container for waterfall related stuff
        waterfall_layout = QHBoxLayout()
        layout.addLayout(waterfall_layout, 3, 0)

        # Waterfall plot
        waterfall = pg.PlotWidget(labels={'left': 'Time [s]', 'bottom': 'Frequency [MHz]'})
        imageitem = pg.ImageItem(axisOrder='col-major') # this arg is purely for performance
        waterfall.addItem(imageitem)
        waterfall.setMouseEnabled(x=False, y=False)
        waterfall_layout.addWidget(waterfall)

        # Colorbar for waterfall
        colorbar = pg.HistogramLUTWidget()
        colorbar.setImageItem(imageitem) # connects the bar to the waterfall imageitem
        colorbar.item.gradient.loadPreset('viridis') # set the color map, also sets the imageitem
        imageitem.setLevels((-30, 20)) # needs to come after colorbar is created for some reason
        waterfall_layout.addWidget(colorbar)

        # Waterfall auto range button
        auto_range_button = QPushButton('Auto Range
(-2σ to +2σ)')
        def update_colormap():
            imageitem.setLevels((self.spectrogram_min, self.spectrogram_max))
            colorbar.setLevels(self.spectrogram_min, self.spectrogram_max)
        auto_range_button.clicked.connect(update_colormap)
        layout.addWidget(auto_range_button, 3, 1)

```

--------------------------------

### Install Phaser Software on Raspberry Pi

Source: https://pysdr.org/content/phaser.html

Run these commands after booting the Raspberry Pi with the pre-built image to download, make executable, and run the setup script. A reboot and raspi-config are recommended afterwards.

```bash
wget https://github.com/mthoren-adi/rpi_setup_stuff/raw/main/phaser/phaser_sdcard_setup.sh
sudo chmod +x phaser_sdcard_setup.sh
./phaser_sdcard_setup.sh
sudo reboot

sudo raspi-config

```

--------------------------------

### BPSK Differential Encoding Example (Step 1)

Source: https://pysdr.org/content/digital_modulation.html

Illustrates the initial step of BPSK differential encoding, showing the input bits and the starting output bit.

```text
Input:     1 1 0 0 1 1 1 1 1 0
Output:  1

```

--------------------------------

### Install UHD and Python API from Source

Source: https://pysdr.org/content/usrp.html

Commands to update apt, install dependencies, install Python packages, clone UHD, checkout a specific version, configure the build with Python API enabled, and install.

```bash
sudo apt update
sudo apt install git cmake libboost-all-dev libusb-1.0-0-dev build-essential
sudo pip install pybind11[global]
pip install numpy==1.26.4 docutils mako requests ruamel.yaml setuptools
cd ~
git clone https://github.com/EttusResearch/uhd.git
cd uhd
git checkout v4.8.0.0
cd host
mkdir build
cd build
cmake -DENABLE_TESTS=OFF -DENABLE_C_API=OFF -DENABLE_PYTHON_API=ON -DENABLE_MANUAL=OFF ..
make -j8
sudo make install
sudo ldconfig
```

--------------------------------

### Python Example: Real-Time Packet Detection

Source: https://pysdr.org/content/detection.html

Shows an implementation for real-time packet detection within continuous IQ streams. This is crucial for identifying the start and end of data packets in a streaming environment.

```python
import numpy as np
from scipy.signal import correlate
import matplotlib.pyplot as plt
import time

def detect_packet_realtime(iq_stream_buffer, preamble):
    """Detects a packet preamble in a buffer of IQ data.

    Args:
        iq_stream_buffer (np.ndarray): A buffer of incoming IQ data.
        preamble (np.ndarray): The known preamble sequence of the packet.

    Returns:
        bool: True if preamble is detected, False otherwise.
        int: The index where the preamble was detected (if found).
    """
    # Correlate the buffer with the preamble
    # Use 'valid' mode to find occurrences where the preamble fully matches
    correlation = correlate(iq_stream_buffer, preamble, mode='valid')

    # Find peaks in the correlation output
    # A simple threshold can be used, or more advanced peak detection
    # For real-time, you might process this continuously
    threshold = 0.7 * np.max(np.abs(correlation)) # Example threshold

    peaks, _ = find_peaks(np.abs(correlation), height=threshold)

    if len(peaks) > 0:
        # Return the index of the first detected peak relative to the buffer start
        detection_index = peaks[0]
        return True, detection_index
    else:
        return False, -1

# --- Example Usage (Simulated Real-Time Stream) ---
fs = 1e6  # Sample rate
preamble_len = 128  # Length of the preamble
packet_len = 1024  # Total packet length
stream_buffer_size = 2048 # Size of the buffer to process

# Generate a random preamble
preamble = (np.random.randint(0, 2, preamble_len) * 2 - 1).astype(np.complex64)

# Simulate incoming IQ stream
def simulate_iq_stream(num_packets=5, packet_interval=1.0, noise_level=0.2):
    total_duration = num_packets * packet_interval
    num_samples = int(fs * total_duration)
    stream = np.zeros(num_samples, dtype=np.complex64)

    for i in range(num_packets):
        packet_start = int(i * packet_interval * fs)
        packet_end = packet_start + packet_len
        if packet_end > num_samples:
            packet_end = num_samples

        # Create a simple packet structure (e.g., preamble + random data)
        packet_data = np.random.randn(packet_len - preamble_len) + 1j * np.random.randn(packet_len - preamble_len)
        current_packet = np.concatenate((preamble, packet_data))
        stream[packet_start:packet_end] = current_packet[:packet_end-packet_start]

    # Add noise
    noise = (np.random.randn(num_samples) + 1j * np.random.randn(num_samples)) * noise_level
    return stream + noise


iq_stream = simulate_iq_stream()

# Process the stream in chunks (simulating real-time)
processed_samples = 0
packet_detected = False
packet_start_index = -1

print("Starting real-time packet detection simulation...")

while processed_samples < len(iq_stream):
    # Define the buffer to analyze
    buffer_end = min(processed_samples + stream_buffer_size, len(iq_stream))
    current_buffer = iq_stream[processed_samples:buffer_end]

    # Ensure buffer is large enough to contain preamble for correlation
    if len(current_buffer) >= preamble_len:
        is_detected, detection_idx = detect_packet_realtime(current_buffer, preamble)

        if is_detected:
            packet_start_index = processed_samples + detection_idx
            print(f"Packet preamble detected at sample index: {packet_start_index}")
            packet_detected = True
            # In a real system, you would now process the packet data
            # For simulation, we can stop or skip ahead
            break # Stop after first detection for simplicity

    processed_samples += stream_buffer_size # Move to the next buffer
    # time.sleep(0.01) # Simulate real-time delay

if not packet_detected:
    print("No packet preamble detected in the stream.")

# Optional: Plot a section of the stream and correlation for visualization
if packet_detected:
    plot_start = max(0, packet_start_index - preamble_len * 2)
    plot_end = min(len(iq_stream), packet_start_index + packet_len + preamble_len)
    plot_buffer = iq_stream[plot_start:plot_end]
    plot_lags = np.arange(len(plot_buffer) - preamble_len + 1)
    plot_correlation = correlate(plot_buffer, preamble, mode='valid')

    plt.figure(figsize=(12, 8))

    plt.subplot(2, 1, 1)
    plt.plot(np.arange(plot_start, plot_end), np.abs(plot_buffer))
    plt.title('IQ Stream Segment')
    plt.xlabel('Sample Index')
    plt.ylabel('Magnitude')
    plt.axvline(packet_start_index, color='r', linestyle='--', label='Detected Preamble Start')
    plt.legend()
    plt.grid(True)

    plt.subplot(2, 1, 2)
    plt.plot(plot_lags + plot_start, np.abs(plot_correlation))
    plt.title('Correlation with Preamble')
    plt.xlabel('Sample Index')
    plt.ylabel('Correlation Magnitude')
    plt.axvline(packet_start_index, color='r', linestyle='--', label='Detected Preamble Start')
    plt.legend()
    plt.grid(True)

    plt.tight_layout()
    plt.show()

```

--------------------------------

### Install PlutoSDR Drivers and APIs

Source: https://pysdr.org/content/pluto.html

Installs libiio, libad9361-iio, and pyadi-iio. Ensure build tools and dependencies are installed first. This process requires cloning repositories and compiling from source.

```bash
sudo apt-get update
sudo apt-get install build-essential git xml2-dev bison flex libcdk5-dev cmake python3-pip libusb-1.0-0-dev libavahi-client-dev libavahi-common-dev libaio-dev
cd ~
git clone --branch v0.23 https://github.com/analogdevicesinc/libiio.git
cd libiio
mkdir build
cd build
cmake -DPYTHON_BINDINGS=ON ..
make -j$(nproc)
sudo make install
sudo ldconfig

cd ~
git clone https://github.com/analogdevicesinc/libad9361-iio.git
cd libad9361-iio
mkdir build
cd build
cmake ..
make -j$(nproc)
sudo make install

cd ~
git clone --branch v0.0.14 https://github.com/analogdevicesinc/pyadi-iio.git
cd pyadi-iio
pip3 install --upgrade pip
pip3 install -r requirements.txt
sudo python3 setup.py install
```

--------------------------------

### Run Phaser Example App

Source: https://pysdr.org/content/phaser.html

Launch the pre-built example application provided by Analog Devices for the Phaser. Ensure calibration is complete.

```bash
python phaser_gui.py

```

--------------------------------

### Full Example: Simulate Signal and Plot PSD

Source: https://pysdr.org/content/sampling.html

Generates a complex exponential signal with added noise, then calculates and plots its Power Spectral Density (PSD). This example includes necessary imports and sets up simulation parameters.

```python
import numpy as np
import matplotlib.pyplot as plt

Fs = 300 # sample rate
Ts = 1/Fs # sample period
N = 2048 # number of samples to simulate

t = Ts*np.arange(N)
x = np.exp(1j*2*np.pi*50*t) # simulates sinusoid at 50 Hz

n = (np.random.randn(N) + 1j*np.random.randn(N))/np.sqrt(2) # complex noise with unity power
noise_power = 2
r = x + n * np.sqrt(noise_power)

PSD = np.abs(np.fft.fft(r))**2 / (N*Fs)
PSD_log = 10.0*np.log10(PSD)
PSD_shifted = np.fft.fftshift(PSD_log)

f = np.arange(Fs/-2.0, Fs/2.0, Fs/N) # start, stop, step

plt.plot(f, PSD_shifted)
plt.xlabel("Frequency [Hz]")
plt.ylabel("Magnitude [dB]")
plt.grid(True)
plt.show()
```

--------------------------------

### Install pyrtlsdr Python Wrapper

Source: https://pysdr.org/content/rtlsdr.html

Installs the Python wrapper for the librtlsdr library.

```bash
sudo pip install pyrtlsdr
```

--------------------------------

### Install RTL-SDR Software on Ubuntu

Source: https://pysdr.org/content/rtlsdr.html

Installs the librtlsdr library and command-line tools on Debian-based systems.

```bash
sudo apt install rtl-sdr
```

--------------------------------

### Install HackRF Python API

Source: https://pysdr.org/content/hackrf.html

Install the necessary development libraries for USB and then install the python-hackrf package using pip. Ensure you have the correct version.

```bash
sudo apt install libusb-1.0-0-dev
pip install python_hackrf==1.2.7
```

--------------------------------

### Install bladeRF Software on Ubuntu

Source: https://pysdr.org/content/bladerf.html

Installs the libbladerf library, Python bindings, command-line tools, and firmware/FPGA downloaders on Debian-based systems.

```bash
sudo apt update
sudo apt install cmake python3-pip libusb-1.0-0
cd ~
git clone --depth 1 https://github.com/Nuand/bladeRF.git
cd bladeRF/host
mkdir build && cd build
cmake ..
make -j8
sudo make install
sudo ldconfig
cd ../libraries/libbladeRF_bindings/python
sudo python3 setup.py install
```

--------------------------------

### Minimal PyQt Application with a Button

Source: https://pysdr.org/content/pyqt.html

A basic PyQt application demonstrating a main window with a single QPushButton. The button's click signal is connected to a callback function. Install PyQt6 using 'pip install PyQt6'.

```python
from PyQt6.QtWidgets import QApplication, QMainWindow, QPushButton

# Subclass QMainWindow to customize your application's main window
class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()

        # Example GUI component
        example_button = QPushButton('Push Me')
        def on_button_click():
            print("beep")
        example_button.clicked.connect(on_button_click)

        self.setCentralWidget(example_button)

app = QApplication([])
window = MainWindow()
window.show() # Windows are hidden by default
app.exec() # Start the event loop

```

--------------------------------

### Python Example: Detecting GPS Signals

Source: https://pysdr.org/content/detection.html

Illustrates how to detect GPS signals that are below the noise floor using a correlation approach. This example is valuable for understanding signal recovery in challenging conditions.

```python
import numpy as np
from scipy.signal import correlate
import matplotlib.pyplot as plt

def detect_gps_signal(iq_data, gps_template):
    """Detects GPS signals in IQ data using correlation.

    Args:
        iq_data (np.ndarray): The recorded IQ data.
        gps_template (np.ndarray): The GPS signal template.

    Returns:
        tuple: A tuple containing the correlation results and the time lags.
    """
    # Correlate the IQ data with the GPS template
    correlation = correlate(iq_data, gps_template, mode='valid')
    lags = np.arange(len(iq_data) - len(gps_template) + 1)
    return correlation, lags

# --- Example Usage (requires actual GPS IQ data and template) ---
# Load or generate IQ data (replace with your actual data)
# For demonstration, we'll use random data, but this won't find real GPS signals
fs = 2e6  # Sample rate
duration = 1  # seconds
num_samples = int(fs * duration)
iq_data = np.random.randn(num_samples) + 1j * np.random.randn(num_samples)

# Load or generate GPS template (replace with your actual GPS template)
# This is a placeholder and needs to be a valid GPS preamble/code
gps_template = np.random.randn(1024) + 1j * np.random.randn(1024)

# Normalize template for better correlation
gps_template /= np.sqrt(np.mean(np.abs(gps_template)**2))

# Normalize IQ data (optional, depends on recording)
iq_data /= np.sqrt(np.mean(np.abs(iq_data)**2))

correlation_result, time_lags = detect_gps_signal(iq_data, gps_template)

# Plotting the correlation results
plt.figure(figsize=(12, 6))
plt.plot(time_lags / fs, np.abs(correlation_result))
plt.title('GPS Signal Detection using Correlation')
plt.xlabel('Time (s)')
plt.ylabel('Correlation Magnitude')
plt.grid(True)
plt.show()

# Find peaks in the correlation to identify potential signal occurrences
# This is a simplified peak finding, more robust methods might be needed
from scipy.signal import find_peaks

# Adjust threshold based on noise level and expected signal strength
# A common approach is to use a multiple of the standard deviation of the correlation
threshold = 3 * np.std(np.abs(correlation_result))
peaks, _ = find_peaks(np.abs(correlation_result), height=threshold)

print(f"Potential GPS signal detections at times: {[time_lags[p] / fs for p in peaks]}")

```

--------------------------------

### Probe AntSDR E200 Device Details

Source: https://pysdr.org/content/pluto.html

Use `uhd_usrp_probe` to get detailed information about the AntSDR E200 device, including its hardware configuration and capabilities. This command is useful for verifying device setup and understanding its parameters.

```bash
$ uhd_usrp_probe --args addr=192.168.1.10
[INFO] [UHD] linux; GNU C++ version 11.3.0; Boost_107400; UHD_4.1.0.0-0-d2f0b1b1
[INFO] [ANT] Detected Device: ANTSDR
[INFO] [ANT] Initialize CODEC control...
[INFO] [ANT] Initialize Radio control...
[INFO] [ANT] Performing register loopback test...
[INFO] [ANT] Register loopback test passed
[INFO] [ANT] Performing register loopback test...
[INFO] [ANT] Register loopback test passed
[INFO] [ANT] Setting master clock rate selection to 'automatic'.
[INFO] [ANT] Asking for clock rate 16.000000 MHz...
[INFO] [ANT] Actually got clock rate 16.000000 MHz.
_____________________________________________________
/
|       Device: B-Series Device
|     _____________________________________________________
|    /
|   |       Mboard: B210
|   |   magic: 45568
|   |   eeprom_revision: v0.1
|   |   eeprom_compat: 1
|   |   product: MICROPHASE
|   |   name: ANT
|   |   serial: 0223D80FF0D767EBC6D3AAAA6793E64D
|   |   FPGA Version: 16.0
|   | 
|   |   Time sources:  none, internal, external
|   |   Clock sources: internal, external
|   |   Sensors: ref_locked
|   |     _____________________________________________________
|   |    /
|   |   |       RX DSP: 0
|   |   | 
|   |   |   Freq range: -8.000 to 8.000 MHz
|   |     _____________________________________________________
|   |    /
|   |   |       RX DSP: 1
|   |   | 
|   |   |   Freq range: -8.000 to 8.000 MHz
|   |     _____________________________________________________
|   |    /
|   |   |       RX Dboard: A
|   |   |     _____________________________________________________
|   |   |    /
|   |   |   |       RX Frontend: A
|   |   |   |   Name: FE-RX1
|   |   |   |   Antennas: TX/RX, RX2
|   |   |   |   Sensors: temp, rssi, lo_locked
|   |   |   |   Freq range: 50.000 to 6000.000 MHz
|   |   |   |   Gain range PGA: 0.0 to 76.0 step 1.0 dB
|   |   |   |   Bandwidth range: 200000.0 to 56000000.0 step 0.0 Hz
|   |   |   |   Connection Type: IQ
|   |   |   |   Uses LO offset: No
|   |   |     _____________________________________________________
|   |   |    /
|   |   |   |       RX Frontend: B
|   |   |   |   Name: FE-RX2
|   |   |   |   Antennas: TX/RX, RX2
|   |   |   |   Sensors: temp, rssi, lo_locked
|   |   |   |   Freq range: 50.000 to 6000.000 MHz
|   |   |   |   Gain range PGA: 0.0 to 76.0 step 1.0 dB
|   |   |   |   Bandwidth range: 200000.0 to 56000000.0 step 0.0 Hz
|   |   |   |   Connection Type: IQ
|   |   |   |   Uses LO offset: No
|   |   |     _____________________________________________________
|   |   |    /
|   |   |   |       RX Codec: A
|   |   |   |   Name: B210 RX dual ADC
|   |   |   |   Gain Elements: None
|   |     _____________________________________________________
|   |    /
|   |   |       TX DSP: 0
|   |   | 
|   |   |   Freq range: -8.000 to 8.000 MHz
|   |     _____________________________________________________
|   |    /
|   |   |       TX DSP: 1
|   |   | 
|   |   |   Freq range: -8.000 to 8.000 MHz
|   |     _____________________________________________________
|   |    /
|   |   |       TX Dboard: A
|   |   |     _____________________________________________________
|   |   |    /
|   |   |   |       TX Frontend: A
|   |   |   |   Name: FE-TX1
|   |   |   |   Antennas: TX/RX
|   |   |   |   Sensors: temp, lo_locked
|   |   |   |   Freq range: 50.000 to 6000.000 MHz
|   |   |   |   Gain range PGA: 0.0 to 89.8 step 0.2 dB
|   |   |   |   Bandwidth range: 200000.0 to 56000000.0 step 0.0 Hz
|   |   |   |   Connection Type: IQ
|   |   |   |   Uses LO offset: No
|   |   |     _____________________________________________________
|   |   |    /
|   |   |   |       TX Frontend: B
|   |   |   |   Name: FE-TX2
|   |   |   |   Antennas: TX/RX
|   |   |   |   Sensors: temp, lo_locked
|   |   |   |   Freq range: 50.000 to 6000.000 MHz
|   |   |   |   Gain range PGA: 0.0 to 89.8 step 0.2 dB
|   |   |   |   Bandwidth range: 200000.0 to 56000000.0 step 0.0 Hz
|   |   |   |   Connection Type: IQ
|   |   |   |   Uses LO offset: No
|   |   |     _____________________________________________________
|   |   |    /
|   |   |   |       TX Codec: A
|   |   |   |   Name: B210 TX dual DAC
|   |   |   |   Gain Elements: None

```

--------------------------------

### PyQt GUI Setup with Sliders and Dropdown

Source: https://pysdr.org/content/pyqt.html

This snippet demonstrates setting up sliders for frequency and gain, and a QComboBox for sample rate selection within a PyQt application. It connects these widgets to a worker object for updating SDR parameters and includes labels to display current values.

```Python
# Freq slider with label, all units in kHz
freq_slider = QSlider(Qt.Orientation.Horizontal)
freq_slider.setRange(0, int(6e6))
freq_slider.setValue(int(center_freq/1e3))
freq_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
freq_slider.setTickInterval(int(1e6))
freq_slider.sliderMoved.connect(worker.update_freq) # there's also a valueChanged option
freq_label = QLabel()
def update_freq_label(val):
    freq_label.setText("Frequency [MHz]: " + str(val/1e3))
    freq_plot.autoRange()
freq_slider.sliderMoved.connect(update_freq_label)
update_freq_label(freq_slider.value()) # initialize the label
layout.addWidget(freq_slider, 4, 0)
layout.addWidget(freq_label, 4, 1)

# Gain slider with label
gain_slider = QSlider(Qt.Orientation.Horizontal)
gain_slider.setRange(0, 73)
gain_slider.setValue(gain)
gain_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
gain_slider.setTickInterval(2)
gain_slider.sliderMoved.connect(worker.update_gain)
gain_label = QLabel()
def update_gain_label(val):
    gain_label.setText("Gain: " + str(val))
gain_slider.sliderMoved.connect(update_gain_label)
update_gain_label(gain_slider.value()) # initialize the label
layout.addWidget(gain_slider, 5, 0)
layout.addWidget(gain_label, 5, 1)

# Sample rate dropdown using QComboBox
sample_rate_combobox = QComboBox()
sample_rate_combobox.addItems([str(x) + ' MHz' for x in sample_rates])
sample_rate_combobox.setCurrentIndex(0) # should match the default at the top
sample_rate_combobox.currentIndexChanged.connect(worker.update_sample_rate)
sample_rate_label = QLabel()
def update_sample_rate_label(val):
    sample_rate_label.setText("Sample Rate: " + str(sample_rates[val]) + " MHz")
sample_rate_combobox.currentIndexChanged.connect(update_sample_rate_label)
update_sample_rate_label(sample_rate_combobox.currentIndex()) # initialize the label
layout.addWidget(sample_rate_combobox, 6, 0)
layout.addWidget(sample_rate_label, 6, 1)

central_widget = QWidget()
central_widget.setLayout(layout)
self.setCentralWidget(central_widget)
```

--------------------------------

### Advanced Sample Reception with Streaming

Source: https://pysdr.org/content/usrp.html

For more control, use the streaming API instead of convenience functions. This method allows for manual setup of receive rates, frequencies, gains, and stream commands for starting and stopping reception. It's suitable for continuous or specific sample count reception.

```python
import uhd
import numpy as np

usrp = uhd.usrp.MultiUSRP()

num_samps = 10000 # number of samples received
center_freq = 100e6 # Hz
sample_rate = 1e6 # Hz
gain = 50 # dB

usrp.set_rx_rate(sample_rate, 0)
usrp.set_rx_freq(uhd.libpyuhd.types.tune_request(center_freq), 0)
usrp.set_rx_gain(gain, 0)

# Set up the stream and receive buffer
st_args = uhd.usrp.StreamArgs("fc32", "sc16")
st_args.channels = [0]
metadata = uhd.types.RXMetadata()
streamer = usrp.get_rx_stream(st_args)
recv_buffer = np.zeros((1, 1000), dtype=np.complex64)

# Start Stream
stream_cmd = uhd.types.StreamCMD(uhd.types.StreamMode.start_cont)
stream_cmd.stream_now = True
streamer.issue_stream_cmd(stream_cmd)

# Receive Samples
samples = np.zeros(num_samps, dtype=np.complex64)
for i in range(num_samps//1000):
    streamer.recv(recv_buffer, metadata)
    samples[i*1000:(i+1)*1000] = recv_buffer[0]

# Stop Stream
stream_cmd = uhd.types.StreamCMD(uhd.types.StreamMode.stop_cont)
streamer.issue_stream_cmd(stream_cmd)

print(len(samples))
print(samples[0:10])
```

--------------------------------

### DOA Simulation Scenario Setup

Source: https://pysdr.org/content/doa.html

Sets up a simulation scenario with an 8-element array receiving three signals from different angles and powers. This is used to test the performance of DOA estimation techniques.

```python
Nr = 8 # 8 elements
theta1 = 20 / 180 * np.pi # convert to radians
theta2 = 25 / 180 * np.pi
theta3 = -40 / 180 * np.pi
s1 = np.exp(2j * np.pi * d * np.arange(Nr) * np.sin(theta1)).reshape(-1,1) # 8x1
s2 = np.exp(2j * np.pi * d * np.arange(Nr) * np.sin(theta2)).reshape(-1,1)
s3 = np.exp(2j * np.pi * d * np.arange(Nr) * np.sin(theta3)).reshape(-1,1)
# we'll use 3 different frequencies.  1xN
tone1 = np.exp(2j*np.pi*0.01e6*t).reshape(1,-1)
tone2 = np.exp(2j*np.pi*0.02e6*t).reshape(1,-1)
tone3 = np.exp(2j*np.pi*0.03e6*t).reshape(1,-1)
X = s1 @ tone1 + s2 @ tone2 + 0.1 * s3 @ tone3 # note the last one is 1/10th the power
n = np.random.randn(Nr, N) + 1j*np.random.randn(Nr, N)
X = X + 0.05*n # 8xN
```

--------------------------------

### LMS Algorithm Simulation Setup and Execution

Source: https://pysdr.org/content/doa.html

This snippet sets up the simulation parameters, generates the desired signal (SOI) and interfering signals, simulates the received signal with noise, and then applies the LMS algorithm to adaptively estimate the SOI. It logs the mean squared error at each iteration and visualizes the error trend.

```python
# Scenario
sample_rate = 1e6
d = 0.5 # half wavelength spacing
N = 100000 # number of samples to simulate
Nr = 8 # elements
theta_soi = 20 / 180 * np.pi # convert to radians
theta2    = 60 / 180 * np.pi
theta3   = -50 / 180 * np.pi
t = np.arange(N)/sample_rate # time vector
s1 = np.exp(2j * np.pi * d * np.arange(Nr) * np.sin(theta_soi)).reshape(-1,1) # 8x1
s2 = np.exp(2j * np.pi * d * np.arange(Nr) * np.sin(theta2)).reshape(-1,1)
s3 = np.exp(2j * np.pi * d * np.arange(Nr) * np.sin(theta3)).reshape(-1,1)

# SOI is a gold code, repeated, length 127
gold_code = np.array([-1, 1, 1, -1, 1, 1, 1, 1, -1, -1, -1, 1, 1, -1, -1, -1, -1, -1, 1, 1, 1, -1, -1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, -1, -1, 1, 1, -1, -1, 1, -1, 1, -1, -1, 1, -1, -1, -1, -1, -1, -1, 1, 1, -1, 1, -1, 1, -1, 1, 1, -1, -1, -1, -1, 1, 1, 1, -1, 1, -1, 1, 1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, -1, 1, -1, -1, -1, 1, 1, 1, 1, -1, 1, 1, 1, -1, 1, -1, -1, -1, -1, 1, -1, 1, 1, -1, -1, -1, -1, 1, -1, 1, 1, -1, -1, -1, -1, -1, -1, 1, 1])
soi_samples_per_symbol = 8
soi = np.repeat(gold_code, soi_samples_per_symbol)
num_sequence_repeats = int(N / soi.shape[0]) + 1 # number of times to repeat the sequence for N samples
soi = np.tile(soi, num_sequence_repeats)[:N] # repeat the sequence to fill simulated time, then trim
soi = soi.reshape(1, -1) # 1xN

# Interference, eg tone jammers, from different directions
tone2 = np.exp(2j*np.pi*0.02e6*t).reshape(1,-1)
tone3 = np.exp(2j*np.pi*0.03e6*t).reshape(1,-1)

# Simulate received signal
r = s1 @ soi + s2 @ tone2 + s3 @ tone3
n = np.random.randn(Nr, N) + 1j*np.random.randn(Nr, N)
r = r + 0.5*n # 8xN

# LMS, not knowing the direction of SOI but knowing the SOI signal itself
mu = 0.5e-5 # LMS step size
w_lms = np.zeros((Nr, 1), dtype=np.complex128) # start with all zeros

# Loop through received samples
error_log = []
for i in range(N):
   r_sample = r[:, i].reshape(-1, 1) # 8x1
   soi_sample = soi[0, i] # scalar
   y = w_lms.conj().T @ r_sample # apply the weights
   y = y.squeeze() # make it a scalar
   error = soi_sample - y
   error_log.append(np.abs(error)**2)
   w_lms += mu * np.conj(error) * r_sample # weights are still 8x1

w_lms /= np.linalg.norm(w_lms) # normalize weights

plt.plot(error_log)
plt.xlabel('Iteration')
plt.ylabel('Mean Square Error')
plt.show()

# Plot the beam pattern as shown previously

```

--------------------------------

### Initialize Phaser and PlutoSDR in Python

Source: https://pysdr.org/content/phaser.html

Python code to set up the Phaser and PlutoSDR. Requires calibration files to be present. Configures sample rate, gain, and beam direction.

```python
import time
import sys
import matplotlib.pyplot as plt
import numpy as np
import pickle
from adi import ad9361
from adi.cn0566 import CN0566

phase_cal = pickle.load(open("phase_cal_val.pkl", "rb"))
gain_cal = pickle.load(open("gain_cal_val.pkl", "rb"))
signal_freq = pickle.load(open("hb100_freq_val.pkl", "rb"))
d = 0.014  # element to element spacing of the antenna

phaser = CN0566(uri="ip:localhost")
sdr = ad9361(uri="ip:192.168.2.1")
phaser.sdr = sdr
print("PlutoSDR and CN0566 connected!")

time.sleep(0.5) # recommended by Analog Devices

phaser.configure(device_mode="rx")

# Set all antenna elements to half scale - a typical HB100 will have plenty of signal power.
gain = 64 # 64 is about half scale
for i in range(8):
    phaser.set_chan_gain(i, gain, apply_cal=False)

# Aim the beam at boresight (zero degrees)
phaser.set_beam_phase_diff(0.0)

# Misc SDR settings, not super critical to understand
sdr._ctrl.debug_attrs["adi,frequency-division-duplex-mode-enable"].value = "1"
sdr._ctrl.debug_attrs["adi,ensm-enable-txnrx-control-enable"].value = "0" # Disable pin control so spi can move the states
sdr._ctrl.debug_attrs["initialize"].value = "1"
sdr.rx_enabled_channels = [0, 1] # enable Rx1 and Rx2
sdr._rxadc.set_kernel_buffers_count(1) # No stale buffers to flush
sdr.tx_hardwaregain_chan0 = int(-80) # Make sure the Tx channels are attenuated (or off)
sdr.tx_hardwaregain_chan1 = int(-80)

# These settings are basic PlutoSDR settings we have seen before
sample_rate = 30e6
sdr.sample_rate = int(sample_rate)
sdr.rx_buffer_size = int(1024)  # samples per buffer
sdr.rx_rf_bandwidth = int(10e6)  # analog filter bandwidth

# Manually gain (no automatic gain control) so that we can sweep angle and see peaks/nulls
sdr.gain_control_mode_chan0 = "manual"
sdr.gain_control_mode_chan1 = "manual"
sdr.rx_hardwaregain_chan0 = 10 # dB, 0 is the lowest gain.  the HB100 is pretty loud
sdr.rx_hardwaregain_chan1 = 10 # dB

sdr.rx_lo = int(2.2e9) # The Pluto will tune to this freq

# Set the Phaser's PLL (the ADF4159 onboard) to downconvert the HB100 to 2.2 GHz plus a small offset
offset = 1000000 # add a small arbitrary offset just so we're not right at 0 Hz where there's a DC spike
phaser.lo = int(signal_freq + sdr.rx_lo - offset)

```

--------------------------------

### Install Inspectrum on Debian-based Systems

Source: https://pysdr.org/content/iq_files.html

Commands to install the Inspectrum desktop application for RF file analysis on Ubuntu or similar Debian-based Linux distributions. This includes installing dependencies, cloning the repository, and building the application.

```bash
sudo apt-get install qt5-default libfftw3-dev cmake pkg-config libliquid-dev
git clone https://github.com/miek/inspectrum.git
cd inspectrum
mkdir build
cd build
cmake ..
make
sudo make install
inspectrum
```

--------------------------------

### Set QSPI Boot Verbose Environment Variable

Source: https://pysdr.org/content/pluto.html

Configures the Pluto SDR to copy Linux from QSPI flash to RAM and boot. Use this command when SSHed into the Pluto.

```bash
fw_setenv qspiboot_verbose 'adi_hwref;echo Copying Linux from QSPI flash to RAM... && run read_sf && if run adi_loadvals; then echo Loaded AD936x refclk frequency and model into devicetree; fi; envversion;setenv bootargs console=ttyPS0,115200 maxcpus=${maxcpus} rootfstype=ramfs root=/dev/ram0 rw earlyprintk clk_ignore_unused uio_pdrv_genirq.of_id=uio_pdrv_genirq uboot="${uboot-version}" && bootm ${fit_load_address}#${fit_config} || echo BOOT failed entering DFU mode ... && run dfu_sf'
```

--------------------------------

### Filter Taps Example

Source: https://pysdr.org/content/filters.html

An example array of floats representing the 'taps' of a Finite Impulse Response (FIR) filter.

```python
h =  [ 9.92977939e-04  1.08410297e-03  8.51595307e-04  1.64604862e-04
 -1.01714338e-03 -2.46268845e-03 -3.58236429e-03 -3.55412543e-03
 -1.68583512e-03  2.10562324e-03  6.93100252e-03  1.09302641e-02
  1.17766532e-02  7.60955496e-03 -1.90555639e-03 -1.48306750e-02
 -2.69313236e-02 -3.25659606e-02 -2.63400086e-02 -5.04184562e-03
  3.08099470e-02  7.64264738e-02  1.23536693e-01  1.62377258e-01
  1.84320776e-01  1.84320776e-01  1.62377258e-01  1.23536693e-01
  7.64264738e-02  3.08099470e-02 -5.04184562e-03 -2.63400086e-02
 -3.25659606e-02 -2.69313236e-02 -1.48306750e-02 -1.90555639e-03
  7.60955496e-03  1.17766532e-02  1.09302641e-02  6.93100252e-03
  2.10562324e-03 -1.68583512e-03 -3.55412543e-03 -3.58236429e-03
 -2.46268845e-03 -1.01714338e-03  1.64604862e-04  8.51595307e-04
  1.08410297e-03  9.92977939e-04]
```

--------------------------------

### Initialize and Configure HackRF with Python API

Source: https://pysdr.org/content/hackrf.html

Initialize the HackRF library, open a device, set sample rate, frequency, and gain settings, then close the device. This snippet verifies the Python API installation.

```python
from python_hackrf import pyhackrf  # type: ignore
pyhackrf.pyhackrf_init()
sdr = pyhackrf.pyhackrf_open()
sdr.pyhackrf_set_sample_rate(10e6)
sdr.pyhackrf_set_antenna_enable(False)
sdr.pyhackrf_set_freq(100e6)
sdr.pyhackrf_set_amp_enable(False)
sdr.pyhackrf_set_lna_gain(30) # LNA gain - 0 to 40 dB in 8 dB steps
sdr.pyhackrf_set_vga_gain(50) # VGA gain - 0 to 62 dB in 2 dB steps
sdr.pyhackrf_close()
```
Tokens:
Raw