This article presents a comprehensive MATLAB simulation of Differential Phase Shift Keying (DPSK) communication system, covering differential encoding, coherent detection, BER analysis, and performance visualization.

1. System Configuration and Initialization

%% DPSK Communication System Simulation
clear; clc; close all;

% Simulation parameters
symbol_count = 10000;       % Number of symbols
carrier_freq = 10;          % Carrier frequency in Hz
sample_rate = 100;          % Sampling frequency in Hz
symbol_duration = 1;        % Symbol period in seconds
snr_db_values = 0:2:20;     % Signal-to-noise ratio range in dB

% Generate random binary data stream
information_bits = randi([0 1], 1, symbol_count);

% Differential encoding: converts absolute phase to relative phase
% Rule: b(n) = a(n) XOR b(n-1)
differential_bits = xor(information_bits(2:end), information_bits(1:end-1));
differential_bits = [0, differential_bits]; % Prepend reference bit

2. Signal Modulation Process

% Time axis generation
time_axis = 0:1/sample_rate:symbol_duration*symbol_count-1/sample_rate;

% Carrier waveform generation
carrier_wave = cos(2*pi*carrier_freq*time_axis);

% Phase modulation based on differential encoding
modulated_signal = zeros(size(time_axis));
for idx = 1:symbol_count
    % 0 → 0° phase, 1 → 180° phase
    phase_offset = (differential_bits(idx) == 1) * pi;
    segment_start = (idx-1)*sample_rate + 1;
    segment_end = idx*sample_rate;
    modulated_signal(segment_start:segment_end) = ...
        cos(2*pi*carrier_freq*time_axis(segment_start:segment_end) + phase_offset);
end

3. Channel Transmission with AWGN

% Bit error rate storage
error_rate = zeros(size(snr_db_values));

for snr_idx = 1:length(snr_db_values)
    % Compute noise power from specified SNR
    linear_snr = 10^(snr_db_values(snr_idx)/10);
    signal_power = var(modulated_signal);
    noise_variance = signal_power / linear_snr;
    
    % Generate complex Gaussian noise
    noise_term = sqrt(noise_variance/2) * (randn(size(modulated_signal)) + ...
        1j*randn(size(modulated_signal)));
    received_signal = modulated_signal + noise_term;
    
    % Coherent demodulation
    detected_bits = zeros(size(time_axis));
    
    for idx = 1:symbol_count
        segment_start = (idx-1)*sample_rate + 1;
        segment_end = idx*sample_rate;
        
        % Local oscillator with phase rotation
        phase_offset = (differential_bits(idx) == 1) * pi;
        local_oscillator = cos(2*pi*carrier_freq* ...
            (time_axis(segment_start:segment_end) - (idx-1)*symbol_duration) + phase_offset);
        
        % Frequency downconversion
        downconverted = received_signal(segment_start:segment_end) .* local_oscillator;
        
        % FIR lowpass filter design
        lpf = designfilt('lowpassfir', 'CutoffFrequency', 5, 'FilterOrder', 32);
        baseband = filter(lpf, downconverted);
        
        % Differential decision (compare adjacent samples)
        detected_bits(segment_start:segment_end) = (baseband(2:end) > baseband(1:end-1))';
    end
    
    % BER computation
    [~, error_rate(snr_idx)] = biterr(information_bits, detected_bits(1:symbol_count));
end

4. Performance Visualization

figure;

% Plot 1: Original vs differentially encoded data
subplot(3,1,1);
stem(0:symbol_count-1, information_bits, 'b', 0:symbol_count-1, differential_bits, 'r--');
title('Original Data vs Differential Encoding');
xlabel('Symbol Index'); ylabel('Amplitude');
legend('Original Stream', 'Differential Encoded');
grid on;

% Plot 2: Modulated and received signals (first 1000 samples)
subplot(3,1,2);
plot(time_axis(1:1000), modulated_signal(1:1000), 'b-', ...
    time_axis(1:1000), received_signal(1:1000), 'r:');
title('Transmitted and Received Signal Comparison');
xlabel('Time (s)'); ylabel('Amplitude');
legend('Transmitted', 'Received (with noise)');

% Plot 3: BER vs SNR curve
subplot(3,1,3);
semilogy(snr_db_values, error_rate, 'bo-', 'LineWidth', 2, 'MarkerSize', 8);
grid on;
title('Bit Error Rate Performance');
xlabel('SNR (dB)'); ylabel('BER');

5. Component Analysis

Differential Encoding Logic

The ancoding mechanism transforms absolute binary data into relative phase changes:

% Core differential encoding formula: b(n) = a(n) XOR b(n-1)
differential_bits = xor(information_bits(2:end), information_bits(1:end-1));
differential_bits = [0, differential_bits]; % Initial reference state

This approach eliminates phase ambiguity issues since information is encoded in phase transitions rather than absolute phases.

Phase Mapping Scheme

% Binary 0 → 0° phase shift
% Binary 1 → 180° phase shift
phase_offset = (differential_bits(idx) == 1) * pi;

Coherent Detection Strategy

% Synchronized local carrier with delayed recovery
local_oscillator = cos(2*pi*carrier_freq* ...
    (time_axis - (idx-1)*symbol_duration) + phase_offset);

% Envelope detection after lowpass filtering
downconverted = received_signal .* local_oscillator;
filtered_signal = filter(lpf, downconverted);

The delayed carrier synchronization effectively resolves phase ambiguity inherent in non-coherent detection.

6. Performance Evaluation

BER Comparison Table

Performance Metrics

• Spectral Efficiency: 1 bps/Hz
• Noise Tolerance: Approximately 3 dB inferior to coherent PSK
• Implementation Complexity: Lower than coherent PSK systems

7. Practical Applications

Wireless Sensor Networks

% LoRa-style modulation example
spreading_factor = 7;
loramod_output = chirpSpreadMod(information_bits, spreading_factor, carrier_freq, sample_rate);

Satellite Communication Links

% GEO satellite channel simulation
[simulated_ber, theoretical_ber] = spaceLinkAnalysis(loramod_output, carrier_freq, 3e8);