S-0195 - Supplemental 195 - SDR for Satellite Downlinks

Author: Patrick Luan de Mattos
Category Path: sdr-hacking
Audience Level: Advanced
Generated at: 2026-04-02T23:02:26.290Z

Supplemental Chapter: SDR for Satellite Downlinks

Supplemental Index: 195

Title: SDR for Satellite Downlinks

Audience Level: Advanced

Focus Keywords: weather satellite decoding, Doppler compensation, pass prediction, and signal chains

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

This supplemental chapter builds upon foundational concepts typically covered in advanced SDR courses. It assumes proficiency in digital signal processing, software-defined radio principles, and a basic understanding of radio propagation. Specifically, it bridges the gap between general SDR applications and the specialized challenges of receiving and decoding signals from orbiting platforms.

Advanced SDR Roadmap Context:

• Core SDR Principles: Understanding of sampling, quantization, digital filtering, modulation/demodulation.
• Advanced DSP: FFTs, correlation, adaptive filtering, spectral analysis.
• RF Fundamentals: Antenna theory, gain, noise figure, impedance matching, signal-to-noise ratio (SNR).
• Communication Systems: Channel coding, error correction, multiplexing.
• This Chapter: Application of these principles to the unique environment of satellite communications, focusing on downlinks.

2) Deep Conceptual Explanation

Receiving signals from satellites presents a unique set of challenges compared to terrestrial communications. Satellites are distant, their signals traverse the ionosphere and atmosphere, and their relative motion introduces significant frequency shifts. SDR offers an exceptionally flexible and powerful approach to overcoming these hurdles.

The Satellite Downlink Environment

• Distance and Path Loss: Satellites are thousands of kilometers away. The inverse square law dictates a substantial signal attenuation over this distance. This necessitates high-gain antennas and sensitive receivers.
• Doppler Effect: As a satellite moves relative to a ground station, the perceived frequency of its transmitted signal shifts. This Doppler shift can be significant, especially for low Earth orbit (LEO) satellites, and changes continuously during a satellite pass. Failing to compensate for this can cause the signal to drift out of the receiver's bandwidth or distort demodulation.
• Atmospheric and Ionospheric Effects: Signals passing through the Earth's atmosphere and ionosphere can experience absorption, refraction, Faraday rotation (polarization changes), and scintillation (rapid fluctuations in signal amplitude and phase). These effects are frequency-dependent and can vary with time of day, solar activity, and geographic location.
• Limited Pass Times: LEO satellites are only within line-of-sight of a ground station for a limited duration (typically minutes). This "pass window" requires precise timing and efficient data acquisition.
• Signal Structure: Satellite downlinks often employ specialized modulation schemes, error correction codes (ECC), and data multiplexing to maximize data throughput and ensure reliability.

SDR's Role

SDR's inherent flexibility is crucial for satellite downlinks:

• Tunability: SDR receivers can be easily tuned to the precise frequencies of various satellite services.
• Bandwidth Agility: The digital nature of SDR allows for dynamic adjustment of the receiver's bandwidth to match the signal's characteristics and minimize interference.
• Software-Defined Processing: Complex signal processing tasks like Doppler compensation, demodulation, and decoding can be implemented in software, allowing for adaptation to changing conditions and the decoding of diverse signal types.
• Rapid Prototyping: SDR platforms enable rapid experimentation with different reception strategies and decoding algorithms.

3) Architecture and Signal Reasoning

A typical SDR-based satellite downlink receiving system involves several key stages, often referred to as the "signal chain."

Signal Chain Components

1. Antenna:

   • Purpose: To capture the weak radio waves from the satellite.
   • Considerations: Gain (crucial for weak signals), beamwidth (tracking the satellite), polarization (matching the satellite's transmission). For LEO satellites, tracking antennas are often required.
   • Example: A parabolic dish antenna or a high-gain Yagi-Uda antenna.

2. Low-Noise Amplifier (LNA):

   • Purpose: To amplify the weak signal from the antenna before it is further degraded by receiver noise.
   • Considerations: Low noise figure (NF) is paramount to maintain a good Signal-to-Noise Ratio (SNR). Often placed close to the antenna to minimize cable losses.
   • Placement: Typically directly at the antenna feed point or as close as possible.

3. Downconverter (Optional but common):

   • Purpose: To shift the satellite's downlink frequency (often in VHF, UHF, or microwave bands) to a lower intermediate frequency (IF) or directly to baseband for easier processing by the SDR.
   • Considerations: Mixer, local oscillator (LO), and filters.

4. SDR Receiver:

   • Purpose: To digitize the analog radio signal.
   • Components: Analog-to-Digital Converter (ADC), digital front-end (tuners, filters, gain control).
   • Key Parameters: Sampling rate (must be at least twice the signal bandwidth, Nyquist theorem), bit depth (dynamic range), ADC dynamic range.

5. Digital Signal Processing (DSP) Chain:

   • Purpose: To extract meaningful data from the digitized signal. This is where SDR's power truly shines.
   • Key Stages:
     • Tuning and Filtering: Precisely centering the signal and rejecting out-of-band interference.
     • Doppler Compensation: Correcting for the frequency shift caused by the satellite's motion. This is a critical step.
     • Demodulation: Extracting the baseband data from the modulated carrier.
     • Decoding: Applying error correction codes to recover the original data.
     • Data Extraction: Assembling the data into usable formats (e.g., images, telemetry).

6. Data Storage and Analysis:

   • Purpose: Saving the decoded data and performing further analysis or visualization.

Doppler Compensation Reasoning

The Doppler shift ($\Delta f$) is given by:

$\Delta f = f_0 \times \frac{v}{c}$

where:

• $f_0$ is the transmitted frequency.
• $v$ is the relative velocity between the transmitter and receiver along the line of sight.
• $c$ is the speed of light.

For LEO satellites, $v$ can be several kilometers per second, and $f_0$ can be in the GHz range, leading to Doppler shifts of tens or even hundreds of kilohertz. This shift is not constant; it increases as the satellite approaches, reaches a maximum at closest approach, and decreases as it recedes.

Doppler Compensation Techniques:

• Pre-calculated Doppler Shift: Using orbital mechanics to predict the satellite's trajectory and calculate the expected Doppler shift at any given time. This allows the receiver to apply a compensating frequency offset.
• Real-time Doppler Tracking: Analyzing the received signal to estimate the current Doppler shift and adjust the receiver's local oscillator or digital frequency offset accordingly. This is more robust to prediction errors or atmospheric effects. Techniques often involve correlating the received signal with a known pilot tone or using phase-locked loops (PLLs) to track the signal's frequency.

Weather Satellite Decoding Example: NOAA APT

A classic example is decoding Automatic Picture Transmission (APT) signals from NOAA weather satellites.

• Frequency: Typically around 137 MHz (VHF band).
• Modulation: Amplitude Modulation (AM), specifically a form of amplitude shift keying (ASK) or amplitude modulation with a pilot tone.
• Data Rate: 2.4 kbps.
• Signal Structure: The signal contains image data modulated onto an audio subcarrier. A pilot tone is often present for synchronization and Doppler estimation.

Signal Chain for NOAA APT:

1. Antenna: A turnstile antenna or a simple dipole can work for 137 MHz.
2. LNA: A low-noise amplifier optimized for the 137 MHz band.
3. SDR: A wideband SDR capable of capturing at least a few hundred kHz around 137 MHz.
4. DSP:
   • Tuning: To the specific NOAA satellite frequency (e.g., 137.620 MHz for NOAA-19).
   • Doppler Compensation: Crucial as the satellite moves.
   • Demodulation: AM demodulation to extract the audio subcarrier.
   • Filtering: To isolate the audio subcarrier (e.g., around 3.5 kHz).
   • Decoding: The audio signal is then further processed to recover the image data.

4) Python Examples When Applicable

Python, combined with libraries like numpy, scipy, and matplotlib, is excellent for simulating and analyzing signal processing chains. For real-time SDR, it's often used to control SDR hardware and orchestrate the DSP flow, though the heavy lifting of high-rate signal processing is usually done in C/C++ for performance.

Python Example: Simulating Doppler Shift

This example simulates the Doppler shift for a satellite pass.

import numpy as np
import matplotlib.pyplot as plt

# --- Simulation Parameters ---
carrier_frequency = 137e6  # Hz (e.g., NOAA APT frequency)
speed_of_light = 299792458  # m/s
satellite_velocity = 7.5e3  # m/s (approx. LEO satellite speed)
duration = 600  # seconds (10 minutes pass)
sampling_rate = 2e6  # Hz (SDR sampling rate)
time = np.linspace(0, duration, int(duration * sampling_rate), endpoint=False)

# --- Simulate Doppler Shift ---
# Assume velocity is constant for simplicity. In reality, it varies.
# For a simplified scenario, let's assume velocity component along LOS changes sinusoidally
# representing approach and recession.
# A more accurate model would use orbital elements and coordinate transformations.

# Simple sinusoidal approximation of velocity along LOS for demonstration
# This is NOT physically accurate for a full pass but shows frequency variation.
# Let's assume max velocity at closest approach and zero at edges of visibility.
# max_radial_velocity = satellite_velocity * 0.8 # Example
# radial_velocity = max_radial_velocity * np.sin(np.pi * time / duration)

# For a more linear-like Doppler shift during the main part of the pass:
# Let's assume a constant radial velocity for the core of the pass for simplicity.
# A true pass has a parabolic velocity profile.
# We'll simulate a constant velocity for a segment, then zero.
mid_point = duration / 2
start_pass_time = 0
end_pass_time = duration
pass_duration_for_velocity = duration * 0.8 # Assume constant velocity for 80% of pass

if duration > 0:
    radial_velocity = np.zeros_like(time)
    start_vel_idx = int(duration * (1 - 0.8) / 2 * sampling_rate)
    end_vel_idx = int(duration * (1 + 0.8) / 2 * sampling_rate)
    if end_vel_idx > len(radial_velocity):
        end_vel_idx = len(radial_velocity)
    if start_vel_idx < end_vel_idx:
        radial_velocity[start_vel_idx:end_vel_idx] = satellite_velocity

else:
    radial_velocity = np.zeros_like(time)


doppler_shift = carrier_frequency * (radial_velocity / speed_of_light)

# --- Apply Doppler Shift to a Carrier Wave ---
# Simulate a pure sine wave transmitted by the satellite
transmitted_signal = np.sin(2 * np.pi * carrier_frequency * time)

# The received signal's frequency is the transmitted frequency plus the Doppler shift
# If we simulate the received signal directly:
received_signal_frequency = carrier_frequency + doppler_shift
received_signal = np.sin(2 * np.pi * received_signal_frequency * time)

# --- Plotting ---
plt.figure(figsize=(12, 8))

plt.subplot(3, 1, 1)
plt.plot(time, radial_velocity)
plt.title("Simulated Radial Velocity of Satellite")
plt.xlabel("Time (s)")
plt.ylabel("Velocity (m/s)")
plt.grid(True)

plt.subplot(3, 1, 2)
plt.plot(time, doppler_shift)
plt.title("Simulated Doppler Shift")
plt.xlabel("Time (s)")
plt.ylabel("Frequency Shift (Hz)")
plt.grid(True)

plt.subplot(3, 1, 3)
plt.plot(time, received_signal_frequency)
plt.title("Simulated Received Signal Frequency Over Time")
plt.xlabel("Time (s)")
plt.ylabel("Frequency (Hz)")
plt.grid(True)

plt.tight_layout()
plt.show()

# Example of how to use this in a receiver:
# If you know the expected carrier_frequency, you would tune your receiver
# to carrier_frequency - doppler_shift_at_this_moment.
# Or, more practically, you'd adjust your LO or digital frequency offset.

This Python script demonstrates how the Doppler shift changes over time and how it affects the received signal's frequency. In a real SDR system, this doppler_shift value would be used to adjust the receiver's tuning or the digital frequency offset applied to the incoming samples.

5) GNU Radio Examples When Applicable

GNU Radio is an open-source software development toolkit that provides a framework for building signal processing applications. It's widely used for SDR and is particularly well-suited for satellite downlink processing due to its modularity and performance.

GNU Radio Example: Doppler Compensation Block (Conceptual)

While a full GNU Radio flowgraph for satellite decoding is complex, we can illustrate the concept of Doppler compensation. In GNU Radio, this is typically achieved using the freq_xlating_fir_filter block or by directly manipulating the frequency of the USRP source if using hardware with a controllable LO.

Conceptual Flowgraph Element:

Imagine a flowgraph where you have:

1. SDR Source: (e.g., UHD UHD-USRP Source) - Captures raw IQ samples.
2. Doppler Offset Block (Custom or Calculated): This block would take the current time and orbital data (or use a tracking algorithm) to calculate the Doppler shift. It then outputs a complex exponential (a phasor) to multiply with the incoming signal, effectively shifting its frequency.
3. Demodulator: (e.g., Quadrature Demodulator) - Extracts the baseband signal.

Illustrative GNU Radio Block Logic (Conceptual Python):

# This is NOT a direct GNU Radio block implementation, but illustrates the logic
# a custom Doppler compensation block might use.

import numpy as np
import gnuradio.gr as gr

class DopplerCompensator(gr.sync_block):
    def __init__(self, initial_freq, orbital_data_source, sample_rate):
        gr.sync_block.__init__(
            self,
            name="Doppler Compensator",
            in_sig=[np.complex64],
            out_sig=[np.complex64]
        )
        self.initial_freq = initial_freq # The nominal center frequency
        self.orbital_data_source = orbital_data_source # A function/object providing Doppler at time t
        self.sample_rate = sample_rate
        self.phase = 0.0
        self.last_time = gr.get_time() # Using GNU Radio's timing

    def work(self, input_items, output_items):
        in_data = input_items[0]
        out_data = output_items[0]

        current_time = gr.get_time() # Get current time in GNU Radio context
        dt = current_time - self.last_time
        self.last_time = current_time

        # Calculate Doppler shift for this block of samples
        # In a real scenario, this would be more sophisticated, potentially
        # using a per-sample or per-block Doppler rate.
        # For simplicity, let's assume orbital_data_source provides the *instantaneous* Doppler shift.
        # A more common approach is to calculate the *rate* of frequency change.

        # Let's assume orbital_data_source returns the instantaneous Doppler shift
        instantaneous_doppler_shift = self.orbital_data_source(current_time)

        # Calculate the frequency correction to apply
        # This is the frequency that counteracts the Doppler shift.
        correction_frequency = -instantaneous_doppler_shift

        # Generate a complex exponential phasor for frequency correction
        # The phase advance per sample is 2*pi*frequency/sample_rate
        phase_advance = 2 * np.pi * correction_frequency / self.sample_rate
        
        # Apply the phasor to each sample
        for i in range(len(in_data)):
            phasor = gr.complex(np.cos(self.phase), np.sin(self.phase))
            out_data[i] = in_data[i] * phasor
            self.phase += phase_advance
            # Keep phase within -pi to pi for numerical stability
            self.phase = np.mod(self.phase + np.pi, 2*np.pi) - np.pi

        return len(in_data)

# --- How this might be used conceptually in a flowgraph ---
#
# from gnuradio import uhd, analog, digital, gr
# from gnuradio.filter import firdes
# import my_custom_blocks # assuming DopplerCompensator is in this module
#
# # Assume orbital_data_source is a function that looks up Doppler based on time
# # This would typically come from a TLE file and an ephemeris calculation library.
# def get_doppler_shift(t):
#     # Placeholder: In reality, this would involve TLE parsing and calculation
#     # For demonstration, let's simulate a parabolic Doppler shift
#     max_doppler = 50e3 # Hz
#     pass_duration = 600 # seconds
#     if t < 0 or t > pass_duration:
#         return 0
#     # Simple parabolic approximation: f(t) = -max_doppler * (1 - 2*t/pass_duration)^2 + max_doppler
#     # This is a simplified model. Actual velocity is more complex.
#     # A more accurate model uses radial velocity: Doppler = f0 * v_radial / c
#     # Let's use a simpler sine wave for the *rate* of change for demonstration.
#     # This is still a simplification.
#     return -max_doppler * np.sin(np.pi * t / pass_duration) # Negative shift when approaching
#
# samp_rate = 2e6
# center_freq = 137.620e6 # NOAA-19 APT
#
# # Instantiate source
# usrp_source = uhd.usrp_source(
#     ",".join(("", "")), # Device args (e.g., "addr=192.168.10.2")
#     uhd.stream_args(cpu_format="fc32", channels=[0]),
# )
# usrp_source.set_samp_rate(samp_rate)
# usrp_source.set_center_freq(center_freq, 0) # Initial tuning
# usrp_source.set_gain(30, 0) # Set gain
#
# # Instantiate Doppler Compensator
# # Note: The orbital_data_source would need to be more sophisticated in a real app.
# # It would likely use a library to calculate Doppler based on TLE and current time.
# doppler_block = my_custom_blocks.DopplerCompensator(
#     initial_freq=center_freq,
#     orbital_data_source=get_doppler_shift, # Pass the function
#     sample_rate=samp_rate
# )
#
# # Connect blocks (simplified):
# # tb.connect((usrp_source, 0), (doppler_block, 0))
# # ... further processing like demodulation, filtering ...
#
# # In a real flowgraph, you'd likely use a frequency-xlation filter or tune the hardware LO
# # directly based on calculated Doppler. For example:
# # freq_xlation_filter = gr.freq_xlating_fir_filter_ccf(1, firdes.band_pass(1, samp_rate, ...), -doppler_shift_value, samp_rate)
# # This block shifts the *center frequency* of the signal digitally.

GNU Radio's freq_xlating_fir_filter_ccf: This is a more typical way to handle frequency translation in GNU Radio. You calculate the required Doppler shift and then use this block to shift the signal's spectrum.

# Conceptual use of freq_xlating_fir_filter_ccf for Doppler Compensation
# ... (assuming usrp_source is defined as above) ...

# Calculate the Doppler shift at a specific time (or continuously update)
current_doppler_shift = get_doppler_shift(gr.get_time()) # Using the placeholder function

# Filter to shift the signal center frequency by the negative of the Doppler shift
# This effectively brings the signal back to baseband (or closer to it)
# The first argument '1' means decimation factor of 1.
# The second argument is the filter design. For pure frequency translation,
# a simple FIR filter can be used, or the block handles it internally.
# The third argument is the frequency offset in Hz.
# The fourth argument is the sample rate.

freq_shift_offset = -current_doppler_shift # Offset to bring signal to center

# A simple FIR filter might be designed for bandpass, and then the offset is applied.
# For pure frequency translation, the offset is the key.
# The exact filter design depends on the desired bandwidth and transition.
# For simplicity, let's assume a low-pass filter is already applied or this is part of it.
# A common approach is to use the offset parameter directly.

# Example: A low-pass filter followed by frequency translation
# (This is a common pattern, not a direct block for Doppler alone)
# fir_filter = gr.fir_filter_ccf(1, firdes.low_pass(1.0, samp_rate, 100e3, 10e3, firdes.WIN_HAMMING)) # Example low-pass
# freq_translator = gr.freq_xlating_fir_filter_ccf(1, firdes.low_pass(1, samp_rate, 20e3, 5e3), freq_shift_offset, samp_rate) # Filter design for translation

# A simpler approach might be to directly tune the USRP source if hardware allows,
# or use the freq_xlating_fir_filter_ccf with a minimal filter design and a large offset.
# Let's assume we are using freq_xlating_fir_filter_ccf to shift the signal.
# For simplicity, let's use a minimal filter design and rely on the offset.
# The filter taps are often calculated internally for frequency translation.
# For a pure frequency translation, a single frequency shift is applied.

# A more accurate way to use freq_xlating_fir_filter_ccf for Doppler:
# You would typically have a signal already centered after initial tuning.
# The Doppler shift moves this centered signal. You then use freq_xlating_fir_filter_ccf
# to shift it back.
#
# Example:
# nominal_center = 137.620e6
# usrp_source.set_center_freq(nominal_center, 0)
#
# # Later, when Doppler is significant:
# doppler_shift_now = get_doppler_shift(gr.get_time()) # e.g., +25e3 Hz
#
# # We want to shift the signal *down* by 25e3 Hz to bring it back to 0 Hz offset.
# # So, the filter offset is -25e3 Hz.
# filter_offset = -doppler_shift_now
#
# # Using a generic FIR filter that's essentially a matched filter for the desired shift
# # The block itself handles the frequency translation using the offset.
# # The 'taps' parameter is often for the filter shape, but for pure translation,
# # the offset is the key.
#
# # A simplified approach for demonstration:
# # We'll use a filter design that is wide enough to pass the signal and apply the offset.
# # The filter taps are often designed to be a simple low-pass filter if the signal is
# # already close to baseband after hardware downconversion.
# # If the signal is still at IF, then the filter would be a bandpass.
#
# # Assuming the signal is brought to baseband by the SDR hardware (e.g., center_freq = nominal_center + doppler_shift_now)
# # Then the digital offset is applied.
#
# # Let's assume the SDR source is tuned to the *nominal* frequency, and we need to compensate digitally.
# # The freq_xlating_fir_filter_ccf directly shifts the digital signal.
#
# # A typical setup:
# # SDR Source -> Digital Filter (e.g., low-pass) -> Frequency Translator -> Demodulator
#
# # Let's illustrate using the offset directly in the freq_xlating_fir_filter_ccf
#
# # First, apply an initial filter to shape the signal if necessary.
# # For simplicity, assume the SDR provides sufficient bandwidth.
#
# # The block that does the actual frequency translation:
# # This block takes the incoming complex samples, applies a complex exponential
# # based on the offset frequency, and then filters the result.
# # The filter design (taps) determines the bandwidth and transition.
# # For a pure frequency shift, the taps are essentially a delta function if no filtering is desired.
# # However, GNU Radio's block is more sophisticated.
#
# # Simplest conceptual application:
# # If you want to shift a signal by `f_offset`, you can use this block.
# # The filter design specifies the shape of the passband.
#
# # Let's assume we have a signal that's been down-converted to baseband, but it's
# # slightly off-center due to Doppler.
#
# # Example: Shift the signal by -doppler_shift_now
# # This block assumes the input signal is centered around 0 Hz (after initial tuning/downconversion).
#
# # For a signal at nominal_center, and we want to shift it to baseband, we'd tune the SDR to nominal_center + doppler_shift_now.
# # If SDR is tuned to nominal_center, and Doppler is +25kHz, the signal is now at 25kHz.
# # We want to shift it back to 0Hz. So we apply a -25kHz shift.
#
# # A more direct way to use the freq_xlating_fir_filter_ccf:
# # It performs the operation: y[n] = x[n] * exp(-j * 2 * pi * offset * n / samp_rate)
# # followed by FIR filtering.
#
# # So, if the signal is at `carrier_frequency + doppler_shift`, and we want to bring it to 0,
# # we need to multiply by exp(-j * 2 * pi * (carrier_frequency + doppler_shift) * n / samp_rate)
# # This is a large frequency shift.
#
# # A common approach:
# # 1. Tune SDR to nominal_center.
# # 2. Use freq_xlating_fir_filter_ccf with offset = -doppler_shift.
# # This assumes the signal is now at `nominal_center + doppler_shift` and we want to shift it by `-doppler_shift`.
#
# # Let's assume a nominal center frequency and a calculated Doppler offset.
# nominal_sdr_tune = 137.620e6
# usrp_source.set_center_freq(nominal_sdr_tune, 0)
#
# # Calculate the Doppler shift for the current time
# current_doppler = get_doppler_shift(gr.get_time()) # e.g., +25e3 Hz
#
# # The signal is now at nominal_sdr_tune + current_doppler.
# # To bring it to baseband (0 Hz), we need to shift by -(nominal_sdr_tune + current_doppler).
# # However, the SDR is tuned to nominal_sdr_tune. So the signal is at `current_doppler` relative to the SDR's center.
# # We need to shift this `current_doppler` frequency back to 0.
#
# # The offset for freq_xlating_fir_filter_ccf is the frequency to shift *by*.
# # If the signal is at +25kHz, we want to shift it by -25kHz.
#
# # We need to design a filter with appropriate bandwidth.
# # Let's assume a bandwidth of 40kHz for APT signals.
# filter_bandwidth = 40e3
# transition_width = 5e3
# taps = firdes.low_pass(1.0, samp_rate, filter_bandwidth/2, transition_width, firdes.WIN_HAMMING)
#
# # Create the frequency translating filter
# freq_translator = gr.freq_xlating_fir_filter_ccf(
#     1,             # decimation
#     taps,          # filter taps
#     -current_doppler, # Frequency offset (negative to shift down)
#     samp_rate      # sample rate
# )
#
# # Connect blocks:
# # tb.connect((usrp_source, 0), (freq_translator, 0))
# # ... then to demodulator, etc.
#
# # Important: The `current_doppler` value needs to be updated dynamically.
# # This is usually done by setting the `freq_xlating_fir_filter_ccf`'s offset parameter
# # periodically using its `set_center_freq` method or similar.

6) Visual Examples

ASCII Signal Diagram: NOAA APT Signal Structure

This is a highly simplified representation of the baseband signal after demodulation and filtering, showing the audio subcarrier carrying image data.

Time ----->

|          |          |          |          |          |
|  SYNC    |  SYNC    |  IMAGE   |  IMAGE   |  IMAGE   |  SYNC
|  PULSE   |  PULSE   |  DATA    |  DATA    |  DATA    |  PULSE
|          |          | (Varies) | (Varies) | (Varies) |
------------------------------------------------------------
^          ^          ^          ^          ^          ^
|          |          |          |          |          |
Pilot Tone (Constant Frequency)

Modulation: Amplitude of the pilot tone varies based on the data.
The sync pulses are distinct amplitude/frequency changes.

Explanation:

• Pilot Tone: A constant frequency tone (e.g., 3.5 kHz) is used as a carrier for the image data.
• Image Data: The amplitude of this pilot tone is varied according to the image pixel intensity.
• Sync Pulses: Special patterns (e.g., a short gap followed by a longer tone burst) are used to mark the beginning of a scan line or frame, aiding in image reconstruction.

Bit Pattern Example: Illustrating Doppler Shift Effect

Consider a simple digital signal (e.g., a clock pulse). Without Doppler, it's regular. With Doppler, the timing (and thus frequency) shifts.

Ideal Signal (No Doppler):

Bit 0:  10101010
Bit 1:  10101010
Bit 2:  10101010

(Each '1010' represents a fixed duration pulse train)

With Positive Doppler Shift (Appearing Faster):

The bits arrive slightly sooner than expected. The duration of each bit period decreases.

Bit 0:  10101010 (Slightly compressed)
Bit 1:  10101010 (Slightly compressed)
Bit 2:  10101010 (Slightly compressed)

If the Doppler shift is significant and uncompensated, the receiver's clock will fall out of sync, leading to bit errors and corrupted data.

Byte Layout Example: Telemetry Data Packet (Conceptual)

Satellite downlinks often carry telemetry data in structured packets.

Byte Offset:  0    1    2    3    4    5    6    7    ...  N
--------------------------------------------------------------
Field:        Header |  ID  |  Seq |  Len | Data Byte 1 | ... | CRC
--------------------------------------------------------------
Example:      0xAA | 0x01 | 0x05 | 0x0A | 0x12 | 0x34 | ... | 0xXX

• Header: Synchronization bytes (e.g., 0xAA).
• ID: Identifies the type of packet (e.g., telemetry, command ack).
• Seq (Sequence Number): For packet ordering.
• Len (Length): Specifies the size of the data payload.
• Data: The actual telemetry values (e.g., battery voltage, temperature, attitude).
• CRC (Cyclic Redundancy Check): An error detection code.

SDR software would parse this structure after demodulation and decoding.

Flow Illustration: SDR Satellite Downlink System

graph TD
    A[Satellite Transmitter] --> B(Space Channel);
    B --> C{Ground Station Antenna};
    C --> D[LNA];
    D --> E{Downconverter (Optional)};
    E --> F[SDR Receiver (ADC)];
    F --> G{Digital Signal Processing (DSP) Unit};
    G --> H[Doppler Compensation];
    H --> I[Demodulation];
    I --> J[Decoding (ECC)];
    J --> K[Data Extraction];
    K --> L[Data Storage/Display];

    subgraph Ground Station
        C
        D
        E
        F
        G
    end

    subgraph DSP Chain
        H
        I
        J
        K
    end

    %% Styling for clarity
    classDef antenna fill:#f9f,stroke:#333,stroke-width:2px;
    classDef sdr fill:#ccf,stroke:#333,stroke-width:2px;
    classDef dsp fill:#cfc,stroke:#333,stroke-width:2px;
    class C antenna;
    class F sdr;
    class G,H,I,J,K dsp;

7) Defensive and Offensive Implications and Troubleshooting

Defensive Implications

• Signal Integrity: Ensuring the received signal is clean and free from interference is paramount. This involves careful antenna selection, LNA placement, and filtering in the SDR chain.
• Accurate Pass Prediction: Precise knowledge of satellite orbits (using TLE data and prediction software) is crucial for timing and aiming antennas.
• Robust Doppler Compensation: A well-implemented Doppler compensation algorithm is essential for maintaining lock and achieving reliable decoding.
• Interference Mitigation: Identifying and filtering out terrestrial interference (e.g., from

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