Transponders¶
What is a Transponder? Wikipedia says, “it is a device that gathers signals over a range of uplink frequencies and re-transmits them on a different set of downlink frequencies.”
However, in the SCTA Libraries, a Transponder is certainly not a device, or even a class that represents a device. It is an interface between the RF modulated signal and the lab equipment. It is a class that stores only the signal characteristics necessary for the equipment to generate, frequency translate, tune, and measure the signal.
There are many important signal characteristics to define, so the Transponder Class is broken down into sublasses: the Mode Class and Local Oscillator Class. There are also convenient ways to group together similar transponders using Transponder Sets.
Hint
For a quick example of creating a Transponder, jump to the Transponder Constructor method.
Mode Class¶
The Mode class stores the parameters associated with a mode in the MODCOD Specification. The MODCOD Specification Table uses Modes to define the 32 DVB-S2 operational mode configurations and their corresponding SNR and PWR thresholds required to close the satellite link. The Transponder Class defines transponders using modes, including, but not limited to, the ones defined in the MODCOD Spec.
Hint
You can easily create a custom mode or a predefined mode from the MODCOD Spec. See the Mode Constructor method for an example.
Attributes¶
- Broadcast Standard
- Modulation
- Code Rate
Methods¶
- Contructor
Description: A mode object can be initialized 2 different ways. One way is to individually specify broadcast standard, modulation, and code rate. The other way is to specify the MODCOD mode index as an integer in {1, 2, …, 24}.
Inputs: all attributes
Outputs: instance of the Mode class
# Option 1 mode1 = Mode(bcstd="DTV", mod="QPSK", fec="1/2") # Option 2 mode1 = Mode.fromMODCOD(1) # Both definitions are equivalent
Class definition¶
class Mode(object):
def __init__(self, bcstd='DTV', mod='QPSK', fec='1/2'):
"""Constructor.
Default values create a MODCOD Mode 1
~~~~~ Possibilities ~~~~~
bcstd: "DTV", "DVB-S", "DVB-S2"
mod: "QPSK", "8PSK"
fec: "1/2", "3/5", "2/3", "3/4", "4/5",
"5/6", "6/7", "7/8", "8/9", "9/10"
"""
self.bcstd = bcstd # BroadCast STandarD
self.mod = mod # Modulation
self.fec = fec # FEC Rate
@classmethod
def fromMODCOD(cls, index):
bcstd = MODCOD_spec[index]["bcstd"]
mod = MODCOD_spec[index]["mod"]
fec = MODCOD_spec[index]["fec"]
return cls(bcstd, mod, fec)
Local Oscillator Class¶
In a satellite broadcast system, a transponder goes through many frequency translations in its lifetime. The 3 main stages are upconversion at the broadcast center, translation at the satellite, and downconversion at the LNB. Each stage has its own local oscillator (LO) frequency. Furthermore, these LO frequencies are different depending on band: Ku, Ka, etc. The Local Oscillator Class stores this metadata for each transponder and provides convenient methods for calculating the transponder’s uplink and downlink frequencies.
Attributes¶
- Band
- Upconverter LO frequency
- Satellite LO frequency
- Downconverter LO frequency
Methods¶
- getDownconversion(inputFreq)
Description: Calculates the down-converted frequency based on the input frequency and LO frequency.
Inputs: input frequency [MHz] (float)
Outputs: down-converted frequency [MHz] (float)
- getUpconversion(inputFreq)
Description: Calculates the up-converted frequency based on the input frequency and LO frequency.
Inputs: input frequency [MHz] (float)
Outputs: up-converted frequency [MHz] (float)
Class Definition¶
class LocalOsc(object):
def __init__(self, id='LO', freq=0):
"""Constructor.
~~~~~ Possibilities ~~~~~
id: string
freq: positive (float) [MHz]
"""
self.id = id # identifier string
self.freq = freq # LO freq
Transponder Class¶
The Transponder class is defined by a mode, a local oscillator, and all the downlink signal parameters associated with a transponder.
Note
All of the Equipment Classes use transponders to generate lab signals and tune demodulators.
Hint
There is a useful predefined list of all DVB-S2 transponders, which you can pick and choose from using Transponder Sets.
Attributes¶
- ID
- Mode
- Frequency
- Symbol Rate
- Roll-off
- Scrambling ID
- Pilot Symbols
- Antenna Polarization
- Local Oscillator
Methods¶
- Constructor
Description: The transponder must be initialized with all of the above attributes. The mode can be either an integer Mode number or an instance of the Mode Class.
Inputs: all attributes
Outputs: instance of the Transponder class
# Create MODCOD Mode 1 mode1 = Mode.fromMODCOD(1) # Input downlink parameters txpdr1 = Transponder(id="anything-you-want", mode=mode1, freq=974e6, symb=20e6, roll=20, scramb=0, pilot=True) # Equivalent transponder txpdr1 = Transponder(id="anything-you-want", mode=1, freq=974e6, symb=20e6, roll=20, scramb=0, pilot=True)
Class definition¶
class Transponder(object):
def __init__(self, id='txp', mode=1, freq=1074e6, symb=20e6, roll=20, scramb=0, pilot=True, pol=None, LO=None):
"""Constructor.
Default values Create a MODCOD Mode 1 Transponder @ 1074 MHz
~~~~~ Possibilities ~~~~~
mode: integer Mode number or Mode class instance
freq: float in Hz
symb: float in Baud
roll: [0, 100] %
scramb: [0, 2^18-1]
pilot: False, True (off, on)
pol: "LHCP", "RHCP", "horizontal", "vertical"
"""
self.id = id # human-readable identifier
self.mode = mode # Mode class instance
self.freq = freq # Center frequency
self.symb = symb # Symbol rate
self.roll = roll # roll-off
self.scramb = scramb # Scrambling code
self.pilot = pilot # Pilot symbols
self.pol = pol # Antenna polarization
self.LO = LO # Local Oscillator class instance
Transponder Sets¶
Sometimes you might want to group together several transponders that are related. Some predefined groups of transponders are subdivided by:
- Orbital Slot
- Satellite
- Bands
- Market (CONUS/ spot)
- HD/ SD
For example, suppose we are given a group of all transponders from one satellite and a group of all spot-beam transponders across all satellites. Suppose we want only the spot-beam transponders from that one satellite. What we want is the intersection of these two groups. To accomplish this, we use python sets
.
- set
- In Python, a set is an unordered collection with no duplicate elements.
Hint
For example, say we have a list of transponders, and some of them are identical in mode and downlink parameters. If we create a set
from this list, all the duplicate transponders would be filtered out, and the list’s original order is not guaranteed.
- set operations
- Python supports set operations like union, intersection, difference, and exclusive or.
For example, we might want to test only the LHCP transponders from satellites in Orbital Slot 101W. We could make a custom set of all LHCP transponders and intersect that with the predefined set of 101W transponders. The possibilities are endless.
Here is the corresponding pseudocode:
# Create 3 hypothetical transponders
txpdr1 = Transponder(id='101W-txpdr1', mode=1, freq=250e6, pol="RHCP")
txpdr2 = Transponder(id='101W-txpdr2', mode=1, freq=950e6, pol="LHCP")
txpdr3 = Transponder(id='99W-txpdr5', mode=1, freq=2150e6, pol="LHCP")
# Group the transponders into hypothetical sets
slot101 = set([txpdr1, txpdr2])
lhcp = set([txpdr2, txpdr3])
# I want all slot 101 W, LHCP transponders
intersect = slot101 & lhcp