Communication Systems

Communication systems enable the reliable transmission of information from one location to another. Understanding how information is encoded, transmitted, and decoded is fundamental to modern technology, from radio communications to internet data transmission to satellite systems.

Information Theory Fundamentals

Entropy and Information Content

Shannon Entropy

H(X) = -\sum_{i=1}^{n} p(x_i) \log_2 p(x_i)

Where $H(X)$ is the entropy of random variable $X$ , and $p(x_i)$ is the probability of symbol $x_i$ .

Information Content

I(x_i) = -\log_2 p(x_i)

The information content of a symbol is inversely related to its probability of occurrence.

Channel Capacity

Shannon-Hartley Theorem

C = B \log_2\left(1 + \frac{S}{N}\right)

Where:

$C$ is channel capacity (bits/second)
$B$ is bandwidth (Hz)
$S$ is signal power
$N$ is noise power

Practical Considerations

C_{practical} = \eta \cdot C_{theoretical}

Where $\eta$ is the channel efficiency factor (typically 0.5-0.9).

Analog Communication Systems

Amplitude Modulation (AM)

Standard AM

s(t) = A_c[1 + m \cdot m(t)] \cos(2\pi f_c t)

Where $A_c$ is carrier amplitude, $m(t)$ is message signal, and $m$ is modulation index.

Modulation Index

\text{Modulation index}: \mu = \frac{\text{max}|m(t)|}{A_c}

For standard AM: $0 \leq \mu \leq 1$ to avoid overmodulation.

Power Efficiency

\text{Efficiency} = \frac{P_{sidebands}}{P_{total}} = \frac{m^2}{2 + m^2}

Frequency and Phase Modulation

Frequency Modulation (FM)

s(t) = A_c \cos\left(2\pi f_c t + 2\pi k_f \int_0^t m(\tau) d\tau\right)

Where $k_f$ is the frequency deviation constant.

Phase Modulation (PM)

s(t) = A_c \cos(2\pi f_c t + k_p m(t))

Where $k_p$ is the phase deviation constant.

Carson's Rule (FM Bandwidth)

B_{FM} = 2(\Delta f + f_m) = 2f_m(\beta + 1)

Where $\Delta f$ is maximum frequency deviation, $f_m$ is maximum modulating frequency, and $\beta$ is modulation index.

Digital Communication Systems

Pulse Code Modulation (PCM)

Sampling Theorem

f_s \geq 2f_{max}

Quantization

\text{Quantization error}: e_q = \pm \frac{\Delta}{2}

\text{Number of quantization levels}: L = 2^n

Where $n$ is the number of bits per sample.

PCM Signal-to-Noise Ratio

\text{SNR}_{quant} = \frac{S}{N} = 2^{2n} \cdot \frac{P_{signal}}{(\Delta/2)^2 \cdot P_{noise}}

For uniform quantization: $\text{SNR}_{dB} \approx 6n + 1.76$ dB.

Digital Modulation Schemes

Binary Modulation

Binary Phase-Shift Keying (BPSK)

s_i(t) = \sqrt{\frac{2E_b}{T_b}} \cos(2\pi f_c t + \theta_i), \quad \theta_i \in \{0, \pi\}

Binary Frequency-Shift Keying (BFSK)

s_i(t) = \sqrt{\frac{2E_b}{T_b}} \cos(2\pi f_i t), \quad i \in \{1, 2\}

M-ary Modulation

M-ary PSK (MPSK)

s_i(t) = \sqrt{\frac{2E_s}{T_s}} \cos(2\pi f_c t + \frac{2\pi i}{M}), \quad i = 0, 1, \ldots, M-1

Where $E_s$ is symbol energy and $T_s$ is symbol period.

M-ary QAM

s_i(t) = I_i \cdot p(t) \cos(2\pi f_c t) - Q_i \cdot p(t) \sin(2\pi f_c t)

Where $I_i$ and $Q_i$ are in-phase and quadrature components.

Bandwidth Efficiency

\eta = \frac{R}{B} = \frac{\log_2 M}{\text{bandwidth per symbol}}

Where $R$ is data rate and $B$ is bandwidth.

Orthogonal Frequency Division Multiplexing (OFDM)

OFDM Signal Model

s(t) = \sum_{k=0}^{N-1} X_k \cdot e^{j2\pi k \Delta f t}, \quad 0 \leq t \leq T

Where $X_k$ are complex symbols, $\Delta f = 1/T$ is subcarrier spacing, and $T$ is symbol duration.

Cyclic Prefix

T_{CP} = \frac{T_s}{4} \text{ to } \frac{T_s}{16}

Where $T_{CP}$ is cyclic prefix duration and $T_s$ is symbol duration.

Error Control Coding

Block Codes

(n, k) Linear Block Code

k: Number of information bits
n: Number of coded bits
Code rate: $R = k/n$

Hamming Distance

d_H(\mathbf{c}_1, \mathbf{c}_2) = \text{number of positions where } c_{1i} \neq c_{2i}

Error Detection and Correction Capability

\text{Detect up to}: d_{min} - 1 \text{ errors}

\text{Correct up to}: \lfloor \frac{d_{min} - 1}{2} \rfloor \text{ errors}

Convolutional Codes

Generator Polynomials

For a (n, k, L) code where L is constraint length:

G(D) = [g_1(D), g_2(D), \ldots, g_n(D)]

Viterbi Algorithm

\text{Branch metric}: \gamma_{k}(s_{m'}, s_m) = d[r_k, u_k(s_{m'}, s_m)]

\text{Path metric}: \Gamma_k(s_m) = \Gamma_{k-1}(s_{m'}) + \gamma_k(s_{m'}, s_m)

Multiple Access Techniques

Time Division Multiple Access (TDMA)

\text{Slot efficiency}: \eta = \frac{\text{information bits}}{\text{information bits} + \text{overhead bits}}

Frequency Division Multiple Access (FDMA)

f_i = f_c + i \cdot \Delta f

Where $f_i$ is the $i$ -th channel frequency.

Code Division Multiple Access (CDMA)

\text{Spreading factor}: SF = \frac{\text{chip rate}}{\text{data rate}}

\text{Processing gain}: PG = 10\log_{10}(SF)

Communication Channels and Noise

Channel Models

Additive White Gaussian Noise (AWGN)

r(t) = s(t) + n(t)

Rayleigh Fading

|h(t)|^2 \sim \text{Exponential}(\lambda)

f_R(r) = \frac{r}{\sigma^2} e^{-r^2/2\sigma^2}, \quad r \geq 0

Noise Analysis

Noise Figure

F = \frac{S_{in}/N_{in}}{S_{out}/N_{out}}

\text{Noise figure in dB}: NF = 10\log_{10}(F)

Cascaded Systems

F_{total} = F_1 + \frac{F_2 - 1}{G_1} + \frac{F_3 - 1}{G_1 G_2} + \ldots

Bit Error Rate (BER)

Coherent BPSK in AWGN

P_e = Q\left(\sqrt{2E_b/N_0}\right)

Where $Q(x) = \frac{1}{\sqrt{2\pi}}\int_x^{\infty} e^{-u^2/2} du$ .

Non-coherent BFSK

P_e = \frac{1}{2}e^{-E_b/2N_0}

Modulation Performance Analysis

Spectral Efficiency

\eta = \frac{\text{bits/second}}{\text{Hertz}} = \frac{R}{B}

Power Efficiency

\text{Power efficiency} = \frac{E_b/N_0}{\text{required for target BER}}

Constellation Design

QPSK Constellation

\text{Symbol points}: \frac{1}{\sqrt{2}}(\pm 1 \pm j)

16-QAM Constellation

\text{Symbol points}: \frac{1}{\sqrt{10}}([(\pm 1, \pm 1) \lor (\pm 3, \pm 3)])

Advanced Digital Techniques

Adaptive Equalization

y(k) = \sum_{i=0}^{N-1} w_i x(k-i)

Where $w_i$ are adaptive filter coefficients and $x(k)$ is the input signal.

Diversity Techniques

Maximal Ratio Combining (MRC)

\text{SNR}_{MRC} = \sum_{i=1}^{L} \text{SNR}_i

Where $L$ is the number of diversity branches.

Space-Time Codes

\mathbf{C} = [c_1, c_2, \ldots, c_n]

Where $\mathbf{C}$ is the space-time code matrix.

Real-World Application: Cellular Communication System Design

Design considerations for cellular communication systems involve complex trade-offs between coverage, capacity, and spectral efficiency.

5G NR System Analysis

# 5G New Radio (NR) system analysis
cellular_params = {
    'frequency_range': 'FR1',  # FR1 (sub-6 GHz) or FR2 (mmWave)
    'carrier_frequency': 3.5e9,  # Hz (3.5 GHz in FR1)
    'bandwidth': 100e6,          # Hz (100 MHz in FR1)
    'subcarrier_spacing': 30e3,   # Hz (30 kHz in FR1)
    'modulation_scheme': '256QAM',  # Modulation type
    'coding_rate': 0.8,           # Forward error correction rate
    'MIMO_config': '4x4',         # Multiple input, multiple output
    'beamforming': True,          # Beamforming enabled
    'channel_model': 'UMa'        # Urban Macrocell model
}

# Calculate key system parameters
if cellular_params['frequency_range'] == 'FR1':
    frequency_range = "450 MHz - 6 GHz"
    max_beamforming_gains = 10  # dB
elif cellular_params['frequency_range'] == 'FR2':
    frequency_range = "24.25 - 52.6 GHz"
    max_beamforming_gains = 20  # dB (much higher at mmWave)

# Calculate symbol rate and subcarriers
symbol_rate = cellular_params['bandwidth'] / cellular_params['subcarrier_spacing']
subcarriers = int(cellular_params['bandwidth'] / cellular_params['subcarrier_spacing'])

# Modulation order for 256QAM
if cellular_params['modulation_scheme'] == '256QAM':
    modulation_order = 256
    bits_per_symbol = 8  # log2(256)
else:
    bits_per_symbol = 6  # For 64QAM

# Calculate theoretical data rate
theoretical_rate = bits_per_symbol * symbol_rate  # bits/second per subcarrier
total_rate = theoretical_rate * subcarriers  # Total bits/second before coding
coded_rate = total_rate * cellular_params['coding_rate']  # After error correction overhead

# Calculate MIMO capacity enhancement
if cellular_params['MIMO_config'] == '4x4':
    spatial_streams = 4
    mimo_gain = 10 * math.log10(spatial_streams)  # dB gain
elif cellular_params['MIMO_config'] == '2x2':
    spatial_streams = 2
    mimo_gain = 10 * math.log10(spatial_streams)
else:
    spatial_streams = 1
    mimo_gain = 0

# Effective capacity calculation with MIMO
effective_capacity = coded_rate * spatial_streams

# Channel capacity with fading considerations
# For urban macro (UMa) channel model
path_loss_exponent = 3.8  # Typical for UMa
reference_distance = 1  # m
reference_loss = 20 * math.log10(4 * math.pi * reference_distance * cellular_params['carrier_frequency'] / 3e8)

# Calculate SNR budget
transmit_power = 23  # dBm (typical base station power)
antenna_gain = 12  # dBi (typical antenna gain)
receive_sensitivity = -95  # dBm (typical receiver sensitivity)
noise_figure = 5  # dB (receiver noise figure)
processing_gain = 10 * math.log10(subcarriers)  # dB

# Total noise power
boltzmann_constant = -174  # dBm/Hz (thermal noise floor)
total_noise_power = boltzmann_constant + 10*math.log10(cellular_params['bandwidth']) + noise_figure

# Calculate link budget
received_power = transmit_power + antenna_gain - reference_loss + 20*math.log10(reference_distance) - (path_loss_exponent * 10)*math.log10(cellular_params['carrier_frequency']/1e9)
snr = received_power - total_noise_power

# Calculate achievable capacity
shannon_capacity = cellular_params['bandwidth'] * math.log2(1 + 10**(snr/10))  # bits/second

print(f"5G NR System Analysis:")
print(f"  Frequency range: {cellular_params['frequency_range']} ({frequency_range})")
print(f"  Carrier frequency: {cellular_params['carrier_frequency']/1e9:.2f} GHz")
print(f"  Bandwidth: {cellular_params['bandwidth']/1e6:.0f} MHz")
print(f"  Subcarrier spacing: {cellular_params['subcarrier_spacing']/1e3:.0f} kHz")
print(f"  Modulation scheme: {cellular_params['modulation_scheme']} ({bits_per_symbol} bits/symbol)")
print(f"  MIMO configuration: {cellular_params['MIMO_config']}")
print(f"  Coding rate: {cellular_params['coding_rate']*100}%")
print(f"  Number of subcarriers: {subcarriers:,}")
print(f"  Symbol rate: {symbol_rate/1e6:.2f} MSymbols/s")

print(f"\nSystem performance:")
print(f"  Theoretical data rate: {theoretical_rate/1e6:.0f} Mbps")
print(f"  Coded data rate: {coded_rate/1e6:.0f} Mbps")
print(f"  MIMO enhancement: {mimo_gain:.1f} dB")
print(f"  Effective capacity: {effective_capacity/1e6:.0f} Mbps")
print(f"  Shannon capacity: {shannon_capacity/1e6:.0f} Mbps")
print(f"  Achievable spectral efficiency: {math.log2(modulation_order):.1f} bits/s/Hz")

# Link budget analysis
print(f"\nLink budget analysis:")
print(f"  Transmit power: {transmit_power} dBm")
print(f"  Antenna gain: {antenna_gain} dBi")
print(f"  Path loss (reference): {reference_loss:.1f} dB")
print(f"  Total noise power: {total_noise_power:.1f} dBm")
print(f"  Received SNR: {snr:.1f} dB")
print(f"  Required SNR for 256QAM: ~22 dB")
print(f"  Link margin: {snr - 22:.1f} dB")

# Coverage assessment
if snr > 22:
    coverage_quality = "Good - 256QAM achievable"
elif snr > 15:
    coverage_quality = "Fair - 64QAM achievable"  
elif snr > 10:
    coverage_quality = "Marginal - QPSK achievable"
else:
    coverage_quality = "Poor - cannot achieve target data rates"

print(f"  Coverage quality assessment: {coverage_quality}")

# Capacity planning
cell_radius = 500  # meters (typical urban cell radius)
cell_area = math.pi * cell_radius**2 / 1e6  # km²
users_per_cell = 100  # typical for 5G dense urban
bits_per_user = effective_capacity / users_per_cell  # bits/s/Hz

print(f"\nCapacity per user: {bits_per_user/1e6:.2f} Mbps")
print(f"  Cell area: {cell_area:.2f} km²")
print(f"  Users per cell: {users_per_cell}")
print(f"  Area spectral efficiency: {effective_capacity/(cell_area*1e6):.2f} bps/Hz/m²")

5G System Design Considerations

Advanced features and system optimization for modern cellular networks.

Your Challenge: Satellite Communication Link Design

Design a satellite communication link and analyze its performance characteristics considering atmospheric effects and system constraints.

Goal: Calculate link budget and optimize system parameters for reliable satellite communication.

Satellite Communication Parameters

import math

# Satellite communication system design
satellite_link = {
    'satellite_type': 'GEO',  # GEO, LEO, MEO
    'uplink_frequency': 6e9,    # Hz (6 GHz - C band)
    'downlink_frequency': 4e9,  # Hz (4 GHz - C band)
    'satellite_altitude': 35800,  # km (GEO altitude)
    'transmit_power': 100,      # W (EIRP)
    'antenna_gain_uplink': 45,  # dBi
    'antenna_gain_downlink': 55,  # dBi
    'receiver_noise_temperature': 150,  # K
    'data_rate': 50e6,          # bps (50 Mbps)
    'modulation_type': '8PSK',   # PSK, QAM, etc.
    'coding_rate': 0.75,        # FEC coding rate
    'pointing_accuracy': 0.1,    # degrees (antenna pointing accuracy)
    'atmospheric_attenuation': 2.0  # dB (at 6GHz, rainy conditions)
}

# Calculate free space loss
c = 2.998e8  # speed of light (m/s)
distance = satellite_params['satellite_altitude'] * 1e3 + 6371e3  # meters (satellite altitude + Earth radius)
distance_to_satellite = math.sqrt(distance**2 - 6371e3**2)  # Direct distance to GEO satellite

# Free space path loss
fsl_uplink = 20 * math.log10(4 * math.pi * distance_to_satellite / (c / satellite_params['uplink_frequency']))
fsl_downlink = 20 * math.log10(4 * math.pi * distance_to_satellite / (c / satellite_params['downlink_frequency']))

# Calculate EIRP (Effective Isotropic Radiated Power)
eirp_uplink_dbw = 10 * math.log10(satellite_params['transmit_power']) + satellite_params['antenna_gain_uplink']
eirp_downlink_dbw = 10 * math.log10(satellite_params['transmit_power']) + satellite_params['antenna_gain_downlink']  # Satellite transmit power

# Calculate received power
received_uplink = eirp_uplink_dbw - fsl_uplink - satellite_params['atmospheric_attenuation'] + satellite_params['antenna_gain_downlink']
received_downlink = eirp_downlink_dbw - fsl_downlink - satellite_params['atmospheric_attenuation'] + satellite_params['antenna_gain_uplink']

# Calculate noise power
boltzmann_constant_db = -228.6  # Boltzmann constant in dB (W/Hz/K)
system_noise_temperature = satellite_params['receiver_noise_temperature']  # K
bandwidth_required = satellite_params['data_rate']  # For uncoded transmission
if satellite_params['modulation_type'] == '8PSK':
    bandwidth_required = bandwidth_required / math.log2(8)  # 3 bits/symbol
elif satellite_params['modulation_type'] == 'QPSK':
    bandwidth_required = bandwidth_required / math.log2(4)  # 2 bits/symbol

# Add implementation margin for practical systems
implementation_margin = 3  # dB (losses in practical systems)

# Calculate SNR
noise_power_dbw = boltzmann_constant_db + 10*math.log10(bandwidth_required) + 10*math.log10(system_noise_temperature)
uplink_snr = received_uplink - noise_power_dbw - implementation_margin
downlink_snr = received_downlink - noise_power_dbw - implementation_margin

# Calculate required SNR for modulation
if satellite_params['modulation_type'] == '8PSK':
    required_snr = 15  # dB for 8PSK at target BER
elif satellite_params['modulation_type'] == 'QPSK':
    required_snr = 10  # dB for QPSK
else:
    required_snr = 18  # dB for higher-order modulation

# Calculate link margins
uplink_margin = uplink_snr - required_snr
downlink_margin = downlink_snr - required_snr

# Calculate spectral efficiency
if satellite_params['modulation_type'] == '8PSK':
    spectral_efficiency = 3  # bits/s/Hz
elif satellite_params['modulation_type'] == 'QPSK':
    spectral_efficiency = 2  # bits/s/Hz
else:
    spectral_efficiency = 1  # bits/s/Hz

# Calculate actual throughput accounting for coding
actual_throughput = bandwidth_required * spectral_efficiency * satellite_params['coding_rate']

# Atmospheric effects analysis
# Rain attenuation varies with frequency
rain_attenuation_factor = 1 + (satellite_params['uplink_frequency'] / 1e9 - 1) * 0.5  # Approximate for C/Ku bands
adjusted_rain_loss = satellite_params['atmospheric_attenuation'] * rain_attenuation_factor

# Calculate availability
# Rain outage probability based on ITU-R P.837 model
# Simplified rain outage probability calculation
rain_outage_probability = 0.01 * (rain_attenuation_factor**0.8)  # Simplified model
availability = (1 - rain_outage_probability) * 100  # %

Analyze satellite communication link performance and optimize parameters.

Hint:

Calculate free space path loss and atmospheric attenuation
Consider both uplink and downlink budgets
Account for system noise temperature and implementation losses
Evaluate the impact of modulation and coding on performance

# TODO: Calculate satellite link parameters
free_space_loss_uplink = 0   # dB (free space path loss for uplink)
free_space_loss_downlink = 0 # dB (free space path loss for downlink)
received_power_uplink = 0    # dBW (power received at satellite)
received_power_downlink = 0  # dBW (power received at ground)
link_margin_uplink = 0      # dB (margin above required SNR)
link_margin_downlink = 0    # dB (margin above required SNR)
availability_percentage = 0 # % (percentage of time link is operational)
spectral_efficiency = 0     # bits/second/Hz
throughput_capacity = 0     # bps (actual data throughput)

# Calculate free space loss for both links (done above)
free_space_loss_uplink = fsl_uplink
free_space_loss_downlink = fsl_downlink

# Calculate received powers (done above)
received_power_uplink = received_uplink
received_power_downlink = received_downlink

# Calculate link margins (done above)
link_margin_uplink = uplink_margin
link_margin_downlink = downlink_margin

# Calculate availability (done above)
availability_percentage = availability

# Calculate spectral efficiency (done above)
if satellite_params['modulation_type'] == '8PSK':
    spectral_efficiency = 3
elif satellite_params['modulation_type'] == 'QPSK':
    spectral_efficiency = 2
else:
    spectral_efficiency = 1

# Calculate throughput capacity
throughput_capacity = actual_throughput

# Print results
print(f"Satellite communication link analysis:")
print(f"  Satellite type: {satellite_params['satellite_type']}")
print(f"  Uplink frequency: {satellite_params['uplink_frequency']/1e9:.1f} GHz")
print(f"  Downlink frequency: {satellite_params['downlink_frequency']/1e9:.1f} GHz")
print(f"  Satellite altitude: {satellite_params['satellite_altitude']} km")
print(f"  Data rate: {satellite_params['data_rate']/1e6:.0f} Mbps")
print(f"  Modulation: {satellite_params['modulation_type']}")
print(f"\nLink budget results:")
print(f"  Free space loss (uplink): {free_space_loss_uplink:.1f} dB")
print(f"  Free space loss (downlink): {free_space_loss_downlink:.1f} dB")
print(f"  Received power (uplink): {received_power_uplink:.2f} dBW")
print(f"  Received power (downlink): {received_power_downlink:.2f} dBW")
print(f"  Link margin (uplink): {link_margin_uplink:.2f} dB")
print(f"  Link margin (downlink): {link_margin_downlink:.2f} dB")
print(f"  System availability: {availability_percentage:.2f}%")
print(f"  Spectral efficiency: {spectral_efficiency:.1f} bits/s/Hz")
print(f"  Throughput capacity: {throughput_capacity/1e6:.2f} Mbps")

# Link assessment
if link_margin_uplink > 10 and link_margin_downlink > 10:
    link_quality = "Excellent - strong link with significant margin"
elif link_margin_uplink > 3 and link_margin_downlink > 3:
    link_quality = "Good - adequate margins for reliable operation"
elif link_margin_uplink > 0 and link_margin_downlink > 0:
    link_quality = "Marginal - may experience outages under adverse conditions"
else:
    link_quality = "Poor - link not viable with current parameters"

print(f"  Link quality: {link_quality}")

# Optimization recommendations
recommendations = []
if link_margin_uplink < 5:
    recommendations.append("Increase uplink transmit power or antenna gain")
if link_margin_downlink < 5:
    recommendations.append("Increase satellite transmit power or ground antenna gain")
if spectral_efficiency < 2:
    recommendations.append("Consider higher-order modulation for better spectral efficiency")
if availability_percentage < 99.5:
    recommendations.append("Implement adaptive modulation or diversity techniques")

print(f"  Optimization recommendations: {recommendations if recommendations else ['System well-designed for current requirements']}")

How would you modify your satellite communication design to support mobile terminals that experience Doppler shifts and varying channel conditions as they move?

Communication Systems

Communication Systems

Information Theory Fundamentals

Entropy and Information Content

Shannon Entropy

Information Content

Channel Capacity

Shannon-Hartley Theorem

Practical Considerations

Analog Communication Systems

Amplitude Modulation (AM)

Standard AM

Modulation Index

Power Efficiency

Frequency and Phase Modulation

Frequency Modulation (FM)

Phase Modulation (PM)

Carson's Rule (FM Bandwidth)

Digital Communication Systems

Pulse Code Modulation (PCM)

Sampling Theorem

Quantization

PCM Signal-to-Noise Ratio

Digital Modulation Schemes

Binary Modulation

Binary Phase-Shift Keying (BPSK)

Binary Frequency-Shift Keying (BFSK)

M-ary Modulation

M-ary PSK (MPSK)

M-ary QAM

Bandwidth Efficiency

Orthogonal Frequency Division Multiplexing (OFDM)

OFDM Signal Model

Cyclic Prefix

Error Control Coding

Block Codes

(n, k) Linear Block Code

Hamming Distance

Error Detection and Correction Capability

Convolutional Codes

Generator Polynomials

Viterbi Algorithm

Multiple Access Techniques

Time Division Multiple Access (TDMA)

Frequency Division Multiple Access (FDMA)

Code Division Multiple Access (CDMA)

Communication Channels and Noise

Channel Models

Additive White Gaussian Noise (AWGN)

Rayleigh Fading

Noise Analysis

Noise Figure

Cascaded Systems

Bit Error Rate (BER)

Coherent BPSK in AWGN

Non-coherent BFSK

Modulation Performance Analysis

Spectral Efficiency

Power Efficiency

Constellation Design

QPSK Constellation

16-QAM Constellation

Advanced Digital Techniques

Adaptive Equalization

Diversity Techniques

Maximal Ratio Combining (MRC)

Space-Time Codes

Real-World Application: Cellular Communication System Design

5G NR System Analysis

5G System Design Considerations

Your Challenge: Satellite Communication Link Design

Satellite Communication Parameters

ELI10 Explanation

Self-Examination