S-0267 - Supplemental 267 - SDR for Satellite Downlinks

Author: Patrick Luan de Mattos
Category Path: sdr-hacking
Audience Level: Advanced
Generated at: 2026-04-03T15:53:19.630Z

Supplemental Chapter: SDR for Satellite Downlinks

267. SDR for Satellite Downlinks

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

This supplemental chapter builds upon foundational knowledge in digital signal processing, radio frequency (RF) engineering, and software-defined radio (SDR) techniques. It assumes a strong understanding of concepts covered in earlier advanced chapters, including:

• Advanced Modulation and Demodulation: Understanding of complex modulation schemes (QPSK, 8PSK, etc.), error correction coding (FEC), and their implementation in SDR.
• RF Chain Design and Analysis: Familiarity with RF front-ends, filters, amplifiers, mixers, and their impact on signal integrity.
• Digital Signal Processing Techniques: Proficiency in FFTs, digital filtering, synchronization, and spectral analysis.
• GNU Radio and Python for SDR: Practical experience in building signal processing chains using GNU Radio and scripting with Python.

This chapter specifically targets the unique challenges and opportunities presented by receiving signals from orbiting platforms, introducing concepts like pass prediction, Doppler compensation, and the specific signal chains involved in weather satellite decoding.

2) Deep Conceptual Explanation

Receiving signals from satellites, particularly for applications like weather satellite decoding, presents a distinct set of challenges compared to terrestrial communications. The primary differentiator is the relative motion between the satellite and the ground station. This motion induces a significant Doppler shift in the received signal frequency, which can vary rapidly during a satellite pass. Without compensation, this shift would cause the demodulator to lose lock, rendering the received data unintelligible.

Pass Prediction is the crucial first step in establishing a downlink. It involves calculating the satellite's trajectory over the horizon for a specific ground station location. This prediction determines:

• Elevation and Azimuth: The angles at which the satellite will appear and disappear, and its highest point in the sky.
• Pass Duration: The time window during which the satellite is visible.
• Maximum Elevation: The peak altitude of the satellite, which influences signal strength.
• Doppler Shift Profile: The expected rate of frequency change throughout the pass.

Doppler Compensation is a real-time process to counteract the frequency shift caused by the satellite's velocity relative to the receiver. As the satellite approaches, the received frequency is higher than the transmitted frequency; as it recedes, the received frequency is lower. This shift needs to be continuously tracked and corrected.

Weather Satellite Decoding often involves receiving data transmitted using specific modulation schemes and encoding. Common examples include APT (Automatic Picture Transmission) for NOAA satellites, which uses analog Frequency Modulation (FM) with audio-frequency signals carrying the image data. More advanced satellites might use digital modulation like QPSK or 8PSK with robust error correction codes. Understanding the specific protocol of the target satellite is paramount.

3) Architecture and Signal Reasoning

The signal chain for satellite downlink reception is designed to handle the unique characteristics of space-borne transmissions.

A. Pass Prediction Module:

This module utilizes orbital elements (e.g., Two-Line Elements or TLEs) of the satellite and the ground station's geographic coordinates. It employs orbital mechanics algorithms to predict the satellite's position and velocity over time.

• Inputs: Satellite TLEs, Ground Station Latitude, Longitude, Altitude, Time.
• Outputs: Time series of satellite Azimuth, Elevation, Range, Velocity, and Doppler Shift.

B. RF Front-End:

This is the hardware that captures the radio waves. For satellite reception, it typically needs to:

• Low Noise Amplifier (LNA): Crucial for amplifying weak satellite signals without adding significant noise.
• Band-Pass Filter (BPF): To isolate the satellite's frequency band of interest and reject out-of-band interference.
• Downconverter (Mixer and Local Oscillator): To shift the high satellite frequency down to a lower Intermediate Frequency (IF) or directly to baseband for digital processing.

C. SDR Receiver:

The SDR's Analog-to-Digital Converter (ADC) samples the IF or baseband signal. The digital signal processing then takes over.

D. Doppler Compensation Module:

This is a critical digital signal processing block. It continuously estimates the current Doppler shift and adjusts the received signal's frequency to bring it back to its nominal value.

• Methods:
  • Open-Loop: Using the pre-calculated Doppler shift profile from the pass prediction module and applying a corresponding frequency correction.
  • Closed-Loop: Employing a frequency-locked loop (FLL) or phase-locked loop (PLL) to dynamically track and compensate for frequency variations.

E. Demodulation and Decoding Module:

Once Doppler compensated, the signal is demodulated according to its specific modulation scheme (e.g., FM for APT, QPSK for digital). This is followed by error correction decoding if applicable.

F. Data Processing and Visualization:

The decoded data, often image data for weather satellites, is then processed, reconstructed, and visualized.

Signal Chain Illustration:

+-----------------+     +-----------------+     +-----------------+     +-----------------+     +-----------------+     +-----------------+
| Pass Prediction | --> | RF Front-End    | --> | SDR Receiver    | --> | Doppler Comp.   | --> | Demodulator     | --> | Data Processor  |
| (Orbital Mech.) |     | (LNA, Filter,   |     | (ADC)           |     | (FLL/PLL, Open/ |     | (FM, QPSK, etc.)|     | & Visualizer    |
|                 |     | Downconverter)  |     |                 |     | Closed Loop)    |     |                 |     |                 |
+-----------------+     +-----------------+     +-----------------+     +-----------------+     +-----------------+     +-----------------+
                                                                                   ^
                                                                                   |
                                                                      (Doppler Profile from Prediction)

Example: NOAA APT Signal Characteristics

NOAA satellites transmit APT signals in the 137 MHz band. The signal is FM modulated, carrying analog audio signals representing image data. The deviation is typically +/- 5 kHz. The audio bandwidth is around 3.4 kHz. The nominal center frequency for a given satellite needs to be known, and the Doppler shift can be several tens of kHz during a pass.

Example: Digital Satellite (e.g., DS-SAR) Signal Characteristics

Digital satellites might use higher frequencies and digital modulations like QPSK or 8PSK, often with Reed-Solomon or LDPC error correction. These signals will have a defined symbol rate and bandwidth.

4) Python Examples When Applicable

Python for Pass Prediction (using skyfield)

The skyfield library is excellent for astronomical calculations, including satellite tracking.

from skyfield.api import Topos, load
from datetime import datetime, timedelta

# Load satellite ephemeris (TLEs)
# You would typically download these from Celestrak or similar sources.
# For this example, we'll use a placeholder.
# Example: NOAA 19 TLEs
# 1 33591U 09005A   23300.50000000  .00000000  00000-0  00000+0 0  999
# 2 33591  99.3000 250.0000 0001000 000.0000 000.0000 15.00000000000000

# Placeholder TLEs for demonstration. Replace with actual TLEs.
tle_url = "https://celestrak.org/NORAD/elements/gp.php?CATNR=25544&FORMAT=TLE" # ISS example
satellites = load.tle_file(tle_url)
iss = satellites[0] # Assuming the first satellite in the file is the one we want

# Define ground station location
# Example: London, UK
earth = load('earth_latest.fsp')
lat, lon = 51.5074, -0.1278  # Latitude, Longitude
ground_station = earth + Topos(latitude_degrees=lat, longitude_degrees=lon)

# Define time range for prediction
now = datetime.utcnow()
start_time = now
end_time = now + timedelta(hours=1)
ts = load.timescale()
t0 = ts.utc(start_time)
t1 = ts.utc(end_time)

# Compute satellite passes
# This function finds times when the satellite is above a certain elevation
# The default elevation is 0 degrees. Let's use 10 degrees for a reasonable pass.
print(f"Predicting passes for {iss.name} from {start_time} to {end_time}...")
times, events = iss.find_events(ground_station, t0, t1, altitude_degrees=10.0,
                                 epoch_days=ts.now(), geodetic=True)

# Print pass details
print("Passes found:")
for t, event in zip(times, events):
    if event == 1:  # 1 means rise, -1 means set
        print(f"  - Rise at: {t.utc_strftime('%Y-%m-%d %H:%M:%S UTC')}")
    elif event == -1:
        print(f"  - Set at: {t.utc_strftime('%Y-%m-%d %H:%M:%S UTC')}")

# To get detailed positions and Doppler shift during a pass, you'd iterate over time points
# For a specific time:
time_of_interest = ts.utc(2023, 10, 27, 12, 0, 0) # Example time
geometry = ground_station.at(time_of_interest)
alt, az, distance = geometry.apparent().altaz()
print(f"\nAt {time_of_interest.utc_strftime('%Y-%m-%d %H:%M:%S UTC')}:")
print(f"  Altitude: {alt.degrees:.2f} degrees")
print(f"  Azimuth: {az.degrees:.2f} degrees")
print(f"  Distance: {distance.km:.2f} km")

# To get Doppler shift, you need the satellite's radial velocity relative to the ground station.
# This is more complex and often involves using specific satellite orbit propagation models.
# Skyfield provides velocity information.
# The Doppler shift formula is approximately: f_doppler = f_carrier * (v_radial / c)
# where v_radial is the radial velocity (positive if moving away, negative if moving towards)
# and c is the speed of light.
# Skyfield's velocity is in km/s. We need to be careful with units.

# Calculate velocity vector
velocity_km_s = geometry.velocity.km_s()
# The radial velocity is the component of the velocity vector along the line of sight
# to the ground station.
radial_velocity_km_s = geometry.apparent().radial_velocity().km_s()

print(f"  Radial Velocity: {radial_velocity_km_s:.4f} km/s")

# Example Doppler calculation for a hypothetical carrier frequency
carrier_frequency_hz = 137e6  # Example: 137 MHz for weather satellites
speed_of_light_m_s = 299792458
speed_of_light_km_s = speed_of_light_m_s / 1e3

# Doppler shift is positive if satellite is moving away (frequency increases)
# Doppler shift is negative if satellite is moving towards (frequency decreases)
# Note: Skyfield's radial_velocity is positive when moving away.
doppler_shift_hz = carrier_frequency_hz * (radial_velocity_km_s / speed_of_light_km_s)
print(f"  Approximate Doppler Shift: {doppler_shift_hz:.2f} Hz")

Python for Doppler Compensation (Conceptual)

This is a simplified conceptual example. A real implementation would be more integrated with the SDR framework.

import numpy as np

class DopplerCompensator:
    def __init__(self, initial_carrier_freq_hz, sample_rate_hz):
        self.current_freq_offset_hz = 0.0
        self.initial_carrier_freq_hz = initial_carrier_freq_hz
        self.sample_rate_hz = sample_rate_hz
        self.time_step = 1.0 / sample_rate_hz

    def update_offset(self, predicted_doppler_rate_hz_per_sec):
        """
        Update the frequency offset based on a predicted rate of change of Doppler.
        This is a simplified open-loop approach.
        """
        # In a real scenario, predicted_doppler_rate_hz_per_sec would come from pass prediction.
        # For closed-loop, this would be driven by an FLL/PLL.
        self.current_freq_offset_hz += predicted_doppler_rate_hz_per_sec * self.time_step
        # Limit the offset to avoid excessive corrections or instability
        max_offset = self.initial_carrier_freq_hz / 2 # Arbitrary limit
        self.current_freq_offset_hz = np.clip(self.current_freq_offset_hz, -max_offset, max_offset)

    def apply_correction(self, signal_block):
        """
        Applies the current frequency offset to a block of samples.
        This is a conceptual representation of frequency shifting.
        A real implementation would use a numerically controlled oscillator (NCO).
        """
        num_samples = len(signal_block)
        t = np.arange(num_samples) * self.time_step
        # Generate a complex sinusoid at the current offset frequency
        correction_tone = np.exp(-1j * 2 * np.pi * self.current_freq_offset_hz * t)
        corrected_signal = signal_block * correction_tone
        return corrected_signal

# --- Usage Example ---
sample_rate = 2e6  # 2 MSps
carrier_freq = 137e6 # 137 MHz
doppler_compensator = DopplerCompensator(carrier_freq, sample_rate)

# Simulate a signal block (e.g., IQ samples)
num_samples_in_block = 1024
# Assume this signal block has a certain Doppler shift.
# In a real scenario, the signal would be received with the shift.
# For simulation, we'll create a signal that *would* be received.
# Let's assume a constant Doppler shift for simplicity here.
simulated_doppler_hz = 35000 # Example: 35 kHz shift
t_sim = np.arange(num_samples_in_block) * (1.0 / sample_rate)
# Simulate a carrier wave with Doppler shift
simulated_iq_data = np.exp(1j * 2 * np.pi * (carrier_freq + simulated_doppler_hz) * t_sim)

print(f"Original simulated signal frequency: {carrier_freq + simulated_doppler_hz:.2f} Hz")

# Simulate passing through a pass where Doppler changes.
# Let's simulate a predicted Doppler rate of change.
# If satellite is at peak elevation and moving tangentially, rate of change might be low.
# If it's rising/setting, rate of change can be higher.
# For simplicity, let's assume a constant Doppler rate of change for this block.
# This would be derived from the derivative of the Doppler shift profile.
# Example: If Doppler shift changes by 100 Hz every second.
predicted_doppler_rate_hz_per_sec = 100.0 # Hz/sec

# Apply Doppler compensation
# In a real system, you'd predict the Doppler offset at the start of the block,
# and then update the offset continuously or at block boundaries.
# Here, we simulate updating the offset *before* applying it.
# In a real FLL/PLL, the offset would be estimated from the signal itself.
doppler_compensator.update_offset(predicted_doppler_rate_hz_per_sec)
print(f"Current frequency offset after update: {doppler_compensator.current_freq_offset_hz:.2f} Hz")

corrected_iq_data = doppler_compensator.apply_correction(simulated_iq_data)

# To verify, you'd analyze the spectrum of corrected_iq_data.
# The peak should now be closer to the original carrier_freq.
# This requires FFT analysis.

5) GNU Radio Examples When Applicable

GNU Radio Flowgraph Snippet: Doppler Compensation (Conceptual)

GNU Radio's freq_xlating_fir_filter can be used for frequency translation. For dynamic Doppler compensation, you'd typically use a block that can update its translation frequency, or a custom block. A common approach is to use a Numerically Controlled Oscillator (NCO) to generate the correction tone.

Here's a conceptual illustration of how you might implement Doppler compensation within a GNU Radio flowgraph. This often involves a block that tracks the frequency error and adjusts an NCO.

graph LR
    A[SDR Source] --> B(Low Pass Filter);
    B --> C(Doppler Estimator/Tracker);
    C --> D{NCO / Frequency Translator};
    D --> E(Demodulator);
    E --> F[Data Sink];

    subgraph Doppler Compensation Loop
        C -- Frequency Error --> D
    end

    %% Explanation:
    %% A: Your SDR hardware (e.g., RTL-SDR, USRP)
    %% B: A filter to remove unwanted out-of-band signals and decimate.
    %% C: This block is the core of closed-loop Doppler compensation.
    %%    It could be a Frequency Locked Loop (FLL) or Phase Locked Loop (PLL) implementation.
    %%    It estimates the frequency offset from the signal and outputs a control signal.
    %% D: This block takes the incoming signal and shifts its frequency by the amount
    %%    determined by the Doppler Estimator. A Numerically Controlled Oscillator (NCO)
    %%    is typically used here. In GNU Radio, this could be achieved with a
    %%    Frequency Xlating FIR Filter where the frequency parameter is dynamically updated,
    %%    or a custom block implementing an NCO.
    %% E: The demodulator appropriate for the satellite signal (e.g., WBFM for APT).
    %% F: Where the decoded data goes (e.g., File Sink, Image Sink).

GNU Radio Block Idea: Dynamic Frequency Translator

While there isn't a single "Doppler Compensator" block out-of-the-box that takes a predicted Doppler profile, you can achieve this by:

1. Using freq_xlating_fir_filter_ccc: This block allows for frequency translation. You can dynamically update its freq parameter. This would require a Python or C++ block to calculate the current frequency offset based on pass prediction and send it to the freq_xlating_fir_filter_ccc.
2. Custom Block: Implementing a custom block that combines an NCO with the incoming signal.

Conceptual Python Block for Dynamic Frequency Translation

# This is a conceptual Python block that could be integrated into GNU Radio.
# It assumes you have a way to get the current Doppler offset.

import numpy as np
import gnuradio.gr as gr
from gnuradio import blocks
from gnuradio import analog

class DopplerCorrectedSource(gr.sync_block):
    def __init__(self, source_block, initial_carrier_freq_hz, sample_rate_hz, doppler_predictor):
        gr.sync_block.__init__(self,
            name="DopplerCorrectedSource",
            in_sig=None, # This block acts like a source, taking no input from previous blocks
            out_sig=[(gr.complex_types.gr_complex)] # Output complex samples
        )
        self.source_block = source_block # The actual SDR source block (e.g., osmosdr.source)
        self.sample_rate_hz = sample_rate_hz
        self.time_step = 1.0 / sample_rate_hz
        self.current_freq_offset_hz = 0.0
        self.doppler_predictor = doppler_predictor # An object with a method to get current Doppler offset

        # Configure the underlying source block
        self.source_block.set_sample_rate(sample_rate_hz)
        # Initial tuning frequency is the nominal carrier frequency of the satellite
        # The Doppler compensation will adjust the received signal's effective frequency.
        self.source_block.set_center_freq(initial_carrier_freq_hz, 0) # Channel 0

        self.nco_phase = 0.0
        self.nco_freq = 0.0 # This will be updated by the predictor

    def work(self, input_items, output_items):
        # Get samples from the actual SDR source
        samples = self.source_block.work(input_items, output_items) # This call needs careful management in GR
        # In a real GR flowgraph, the source would be connected directly.
        # This example is a conceptual wrapper.

        # For this conceptual example, let's assume we get a block of samples.
        # In a real GR flowgraph, you'd have a direct connection from the SDR source.
        # Let's simulate getting a block of samples for processing.
        block_size = 1024 # Example block size
        if not hasattr(self, 'simulated_samples') or len(self.simulated_samples) < block_size:
             # Simulate a signal if no real samples are available for this conceptual block
             t_sim = np.arange(block_size) * self.time_step
             # Add a simulated Doppler shift that the predictor will try to correct
             simulated_doppler_hz = 35000 + 50 * (self.nco_phase / (2 * np.pi)) # Example varying Doppler
             self.simulated_samples = np.exp(1j * 2 * np.pi * (self.source_block.get_center_freq() + simulated_doppler_hz) * t_sim)

        current_samples = self.simulated_samples[:block_size]
        self.simulated_samples = self.simulated_samples[block_size:]

        # Get the current predicted Doppler offset
        self.nco_freq = self.doppler_predictor.get_current_doppler_offset_hz()

        # Generate NCO signal
        t = np.arange(block_size) * self.time_step
        nco_tone = np.exp(-1j * (self.nco_phase + 2 * np.pi * self.nco_freq * t))
        self.nco_phase = (self.nco_phase + 2 * np.pi * self.nco_freq * t[-1]) % (2 * np.pi) # Update phase for next block

        # Apply correction
        corrected_samples = current_samples * nco_tone

        # Place corrected samples into the output buffer
        output_items[0][:block_size] = corrected_samples

        return block_size

# --- Example Usage within a GNU Radio Flowgraph ---
# You would instantiate this block and connect it in your .grc file or Python script.

# Dummy Doppler Predictor class for demonstration
class DummyDopplerPredictor:
    def __init__(self, start_freq=35000, freq_change_rate=50):
        self.current_offset = start_freq
        self.freq_change_rate = freq_change_rate # Hz per second
        self.last_update_time = None
        self.sample_rate = 2e6 # Needs to match the source

    def get_current_doppler_offset_hz(self):
        # In a real scenario, this would query pass prediction data.
        # Here, we simulate a changing Doppler offset.
        import time
        current_time = time.time()
        if self.last_update_time is None:
            self.last_update_time = current_time
            return self.current_offset

        dt = current_time - self.last_update_time
        self.current_offset += self.freq_change_rate * dt
        # Simulate wrap-around or limits if needed
        # self.current_offset = self.current_offset % 100000 # Example wrap
        self.last_update_time = current_time
        return self.current_offset

# --- In your GNU Radio Python script ---
# from gnuradio import gr, blocks, analog, digital, uhd # or other SDR source
# import osmosdr
# import numpy as np
#
# # ... (Setup other blocks like filters, demodulator, etc.)
#
# sample_rate = 2e6
# carrier_freq = 137e6 # Nominal carrier frequency of the satellite
#
# # Instantiate the SDR source (e.g., RTL-SDR)
# # sdr_source = osmosdr.source(args="numchan=1")
# # sdr_source.set_sample_rate(sample_rate)
# # sdr_source.set_center_freq(carrier_freq, 0)
# # sdr_source.set_gain_mode(False, 0) # Manual gain
# # sdr_source.set_gain(40, 0) # Example gain
#
# # Instantiate the dummy predictor
# predictor = DummyDopplerPredictor(start_freq=35000, freq_change_rate=50) # Example parameters
#
# # Instantiate the DopplerCorrectedSource (this is a conceptual block)
# # In a real GR flowgraph, you'd have a direct connection from the SDR source.
# # This wrapper approach is tricky. A more common GR approach is to have the
# # NCO correction applied *after* the SDR source.
#
# # A more standard GR approach:
# # 1. SDR Source -> Low Pass Filter -> Doppler Estimator (FLL/PLL) -> NCO -> Demodulator
#
# # Let's illustrate the NCO part more directly with a standard block.
# # The freq_xlating_fir_filter_ccc can be used if its frequency is updated.
#
# # Example using freq_xlating_fir_filter_ccc (requires external control of 'freq')
# # This is often done with a Python/C++ block that monitors the predictor and updates the filter.
#
# # block_doppler_correction = blocks.freq_xlating_fir_filter_ccc(
# #     demod_rate, # Output sample rate after filtering/decimation
# #     fir_coeffs, # Pre-calculated FIR filter coefficients
# #     initial_freq_offset, # This is the parameter you'd update dynamically
# #     decimation_rate
# # )
#
# # To dynamically update 'initial_freq_offset', you would typically write a custom
# # block or use a controlling Python script that periodically calls a method
# # on the filter block to set its frequency.
#
# # For APT signals, you'd then connect this to a WBFM demodulator.
# # wbfm_demod = digital.wbfm_rx(
# #     demod_rate, # The rate the demodulator expects
# #     audio_decimation # Further decimation for audio output
# # )
#
# # And then to an audio sink or file sink.
# # audio_sink = blocks.audio_sink(sample_rate=audio_sample_rate)

6) Visual Examples

ASCII Signal Diagram: Doppler Shift

Imagine a stationary transmitter (Tx) and receiver (Rx). The signal is a pure sine wave at frequency $f_0$.

Tx ----> Signal @ f0 ----> Rx

Now, the satellite (Tx) is moving towards the receiver (Rx). The received signal appears at a higher frequency, $f_0 + f_{Doppler}$.

Tx (moving) ----> Signal @ f0 + f_Doppler ----> Rx

If the satellite is moving away, the received signal is at a lower frequency, $f_0 - f_{Doppler}$.

Rx <---- Signal @ f0 - f_Doppler ---- (moving) Tx

Bit Pattern Example: Doppler Effect on a Carrier Wave

Let's consider a simple carrier wave.

• Nominal Carrier Frequency: $f_c = 1000$ Hz
• Sample Rate: $f_s = 4000$ Hz
• Signal: Complex Exponential $e^{j 2 \pi f_c t}$

No Doppler Shift:

At time $t = [0, 1/4000, 2/4000, 3/4000]$ seconds, the phase is $[0, 2\pi/4, 4\pi/4, 6\pi/4]$ radians.
The samples (ignoring amplitude) would be approximately:
$e^{j0} \approx 1 + 0j$
$e^{j\pi/2} \approx 0 + 1j$
$e^{j\pi} \approx -1 + 0j$
$e^{j3\pi/2} \approx 0 - 1j$

With Doppler Shift ($f_{Doppler} = 500$ Hz towards Rx):

The effective received frequency is $f_{received} = f_c + f_{Doppler} = 1000 + 500 = 1500$ Hz.
At time $t = [0, 1/4000, 2/4000, 3/4000]$ seconds, the phase is $[0, 2\pi(1500)/4000, 4\pi(1500)/4000, 6\pi(1500)/4000]$ radians.
Phase: $[0, 6\pi/4, 12\pi/4, 18\pi/4]$ radians.
Phase (modulo $2\pi$): $[0, 3\pi/2, 2\pi \equiv 0, 7\pi/2 \equiv 3\pi/2]$ radians.

The samples would be approximately:
$e^{j0} \approx 1 + 0j$
$e^{j3\pi/2} \approx 0 - 1j$
$e^{j0} \approx 1 + 0j$
$e^{j3\pi/2} \approx 0 - 1j$

Notice how the pattern of samples has changed significantly, indicating a higher frequency.

Visualizing Doppler Compensation (Conceptual Spectrum)

Imagine the spectrum of a received signal with a significant Doppler shift. The peak will be shifted away from its nominal frequency.

Before Doppler Compensation:

      ^ Power
      |
      |       #####
      |      #     #
      |     #       #
      |    #         #
      |   #           #
      +------------------------> Frequency
             Nominal Freq     Received Freq (shifted)

After Doppler Compensation:

The compensation shifts the signal back.

      ^ Power
      |
      |       #####
      |      #     #
      |     #       #
      |    #         #
      |   #           #
      +------------------------> Frequency
          Received Freq (corrected) Nominal Freq

7) Defensive and Offensive Implications and Troubleshooting

Defensive Implications:

• Signal Integrity: Accurate Doppler compensation is critical for maintaining signal integrity. Failure to compensate properly will lead to demodulator lock loss and data corruption.
• Interference Rejection: Properly designed RF front-ends (filters, LNAs) are essential. Even with precise Doppler compensation, strong out-of-band interference can overwhelm the desired signal.
• Pass Prediction Accuracy: The accuracy of pass prediction directly impacts the quality of the Doppler compensation profile. Inaccurate TLEs or propagation models can lead to incorrect compensation.
• Adaptive Compensation: For more challenging passes or signals, adaptive Doppler compensation techniques (e.g., closed-loop FLL/PLL) are more robust than open-loop (prediction-based) methods.

Troubleshooting:

• No Signal Lock:
  • Check Pass Prediction: Is the satellite actually overhead? Are the TLEs up-to-date?
  • Antenna Alignment: Is the antenna pointed correctly? Check elevation and azimuth.
  • RF Front-End Issues: Is the LNA working? Is the filter appropriate? Check for signal attenuation.
  • Doppler Compensation: Is the compensation active? Is the offset being applied correctly?
    • Symptom: Spectrum shows a strong signal, but demodulator never locks. This often points to a frequency mismatch.
    • Troubleshooting: Manually adjust the receiver's center frequency to see if you can "catch" the signal as it drifts. If you can track it, your Doppler compensation is likely the issue.
• Garbled Data/Images:
  • Demodulator Settings: Are the modulation parameters (deviation, bandwidth, etc.) set correctly for the satellite?
  • Error Correction: If the satellite uses Forward Error Correction (FEC), is the decoder configured correctly and is the signal strong enough for it to work?
  • Signal-to-Noise Ratio (SNR): Is the signal too weak? Consider a better antenna, LNA, or lower noise figure receiver.
  • Interference: Are there strong interfering signals in the same band? Use spectral analysis to identify them.
• Intermittent Signal:
  • Pass Elevation: Low elevation passes are more prone to atmospheric attenuation and multi-path effects.
  • Antenna Tracking: If using an automated antenna, ensure it's tracking accurately.
  • SDR Stability: Overheating or driver issues can cause intermittent performance.

Offensive Implications (Conceptual/Defensive Context):

While this chapter focuses on legitimate reception, understanding the principles of signal reception, Doppler, and modulation is also fundamental to understanding potential signal disruption or spoofing.

• Jamming: A powerful, out-of-band signal can jam the receiver. A well-designed receiver will have good selectivity to mitigate this.
• Spoofing: Injecting false signals that mimic legitimate satellite transmissions. This is a complex attack, often requiring precise knowledge of the satellite's signal characteristics and timing. Accurate Doppler compensation is a key element to making a spoofed signal appear legitimate.
• Frequency Agility: Satellites might employ frequency hopping or rapid frequency changes. This requires receivers with fast tuning capabilities and sophisticated tracking algorithms.

From a defensive standpoint, understanding these concepts helps in designing systems that are resilient to interference and potential malicious activities. For instance, implementing adaptive filtering and robust Doppler tracking can make a receiver less susceptible to certain types of jamming or spoofing attempts.

8) Summary

Receiving satellite downlinks, particularly for applications like weather satellite decoding, necessitates specialized techniques. Pass prediction provides the essential orbital and timing information. The primary challenge is the Doppler shift caused by the relative motion between the satellite and the ground station, which requires precise real-time Doppler compensation. The signal chain involves a robust RF front-end, an SDR for digitization, and sophisticated digital signal processing for demodulation and decoding. Python libraries like skyfield are invaluable for pass prediction, while GNU Radio offers a

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