MATLAB Code for ASK, FSK, and PSK (with Online Simulator)

📘 Overview & Theory
🧮 MATLAB Code for ASK
🧮 MATLAB Code for FSK
🧮 MATLAB Code for PSK
🧮 Simulator for binary ASK, FSK, and PSK Modulations
📚 Further Reading

MATLAB Code for ASK Modulation and Demodulation

% The code is written by SalimWireless.Com 
% Clear previous data and plots
clc;
clear all;
close all;

% Parameters
Tb = 1;             % Bit duration (s)
fc = 10;            % Carrier frequency (Hz)
N_bits = 10;        % Number of bits
Fs = 100 * fc;      % Sampling frequency (ensure at least 2*fc, more for better representation)
Ts = 1/Fs;          % Sampling interval
samples_per_bit = Fs * Tb; % Number of samples per bit duration

% Generate random binary data
rng(10);            % Set random seed for reproducibility
binary_data = randi([0, 1], 1, N_bits); % Generate random binary data (0 or 1)

% Initialize arrays for continuous signals
t_overall = 0:Ts:(N_bits * Tb) - Ts; % Overall time vector for all bits
message_signal_overall = zeros(1, length(t_overall));
ask_signal_overall = zeros(1, length(t_overall));
carrier_signal_overall = zeros(1, length(t_overall)); % To plot the continuous carrier

% Generate the continuous carrier signal for the entire duration
carrier_template = sqrt(2/Tb) * sin(2*pi*fc*(0:Ts:Tb-Ts)); % Carrier for one bit duration

% --- ASK Modulation ---
for i = 1:N_bits
    % Determine the current bit value
    current_bit = binary_data(i);

% Define time segment for the current bit
    t_start_bit = (i-1) * Tb;
    t_end_bit = i * Tb;
    t_segment_indices = ((i-1)*samples_per_bit + 1) : (i*samples_per_bit);

% Generate message signal for the current bit
    if current_bit == 1
        message_segment = ones(1, samples_per_bit);
    else % current_bit == 0
        message_segment = zeros(1, samples_per_bit);
    end

% Get the carrier for this bit segment (can just repeat the template)
    carrier_segment = carrier_template; % This assumes carrier_template has 'samples_per_bit' length

% Modulate message with carrier for the current bit
    ask_segment = carrier_segment .* message_segment;

% Store segments into overall signals
    message_signal_overall(t_segment_indices) = message_segment;
    ask_signal_overall(t_segment_indices) = ask_segment;
    carrier_signal_overall(t_segment_indices) = carrier_segment; % Store for continuous plot
end

% Plotting
figure;

% Plot binary data bits
subplot(5,1,1);
stem(0:N_bits-1, binary_data, 'filled');
title('Binary Data Bits');
xlabel('Bit Index');
ylabel('Bit Value');
grid on;
axis([-1 N_bits -0.5 1.5]); % Adjust x-axis for stem plot

% Plot continuous Message Signal
subplot(5,1,2);
plot(t_overall, message_signal_overall, 'r');
title('Message Signal');
xlabel('Time (s)');
ylabel('m(t)');
grid on;
axis([0 N_bits*Tb -0.5 1.5]);

% Plot continuous Carrier Signal
subplot(5,1,3);
plot(t_overall, carrier_signal_overall);
title('Carrier Signal');
xlabel('Time (s)');
ylabel('c(t)');
grid on;
axis([0 N_bits*Tb -max(abs(carrier_template))*1.1 max(abs(carrier_template))*1.1]);

% Plot continuous ASK Signal
subplot(5,1,4);
plot(t_overall, ask_signal_overall);
title('ASK Modulated Signal');
xlabel('Time (s)');
ylabel('s(t)');
grid on;
axis([0 N_bits*Tb -max(abs(carrier_template))*1.1 max(abs(carrier_template))*1.1]);

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ASK Demodulation %%%%%%%%%%%%%%%%%%
demodulated_data = zeros(1, N_bits);

for i = 1:N_bits
    % Define time segment for the current bit
    t_segment_indices = ((i-1)*samples_per_bit + 1) : (i*samples_per_bit);

% Extract the modulated signal segment for the current bit
    ask_segment_rx = ask_signal_overall(t_segment_indices);

% Generate local carrier for demodulation (coherent demodulation)
    local_carrier_segment = sqrt(2/Tb) * sin(2*pi*fc*(0:Ts:Tb-Ts));

% Correlator (Integrate-and-dump)
    % Summing the product is an approximation of integration for discrete samples
    correlation = sum(ask_segment_rx .* local_carrier_segment);

% Decision device (thresholding)
    % The threshold depends on the energy of the carrier. If carrier_amplitude is A,
    % and the signal is A*sin(wt) for '1' and 0 for '0', then correlation for '1'
    % would be sum(A*sin^2(wt)), which is positive. For '0', it's 0.
    % A simple positive/negative threshold works if signal is clean.
    if correlation > (samples_per_bit * (1/2) * (sqrt(2/Tb))^2 / 2) * 0.5 % Threshold around half the energy of a '1' bit
        demodulated_data(i) = 1;
    else
        demodulated_data(i) = 0;
    end
end

% Plot demodulated binary data bits
subplot(5,1,5);
stem(0:N_bits-1, demodulated_data, 'filled');
title('ASK Demodulated Data');
xlabel('Bit Index');
ylabel('b(n)');
grid on;
axis([-1 N_bits -0.5 1.5]);

% Verify accuracy
fprintf('Original Data:     %s\n', num2str(binary_data));
fprintf('Demodulated Data:  %s\n', num2str(demodulated_data));
errors = sum(binary_data ~= demodulated_data);
fprintf('Number of errors:  %d\n', errors);
web('https://www.salimwireless.com/search?q=ASK%20MATLAB', '-browser');

Output

Fig 1: ASK Modulation and Demodulation

MATLAB Code for FSK Modulation and Demodulation

% The code is written by SalimWireless.Com 
% Clear the workspace, command window, and close all figures
clc;
clear;
close all;

% Parameters
Fs = 1000;          % Sampling frequency (Hz)
fc1 = 20;           % Carrier frequency for bit 0 (Hz) - Increased for better visualization
fc2 = 50;           % Carrier frequency for bit 1 (Hz) - Increased for better visualization
Tb = 1;             % Duration of each bit in seconds
num_bits = 10;      % Number of bits
Ts = 1/Fs;          % Sampling interval
samples_per_bit = Fs * Tb; % Number of samples per bit duration

% Generate random bits
rng(20);            % Set random seed for reproducibility
bits = randi([0, 1], 1, num_bits);

% Time vector for one bit duration
t_bit = 0:Ts:Tb-Ts;

% FSK modulation
modulated_signal = []; % Empty array for modulated signal

% Modulating each bit
for bit = bits
    if bit == 0
        % Modulate with carrier frequency fc1 for bit 0
        modulated_signal = [modulated_signal sin(2*pi*fc1*t_bit)];
    else
        % Modulate with carrier frequency fc2 for bit 1
        modulated_signal = [modulated_signal sin(2*pi*fc2*t_bit)];
    end
end

% Overall time vector for plotting modulated signal
t_overall_fsk = 0:Ts:(num_bits * Tb) - Ts;

% Plot original information bits
figure;
subplot(3,1,1); % Changed to 3 subplots
stem(0:num_bits-1, bits, 'filled', 'Marker', 'o', 'Color', 'b');
title('Original Information Bits');
xlabel('Bit Index');
ylabel('Bit Value');
grid on;
axis([-1 num_bits -0.5 1.5]);

% Plot modulated signal
subplot(3,1,2); % Changed to 3 subplots
plot(t_overall_fsk, modulated_signal);
title('FSK Modulated Signal');
xlabel('Time (s)');
ylabel('Amplitude');
grid on;
% Adjust Y-axis limits based on amplitude range
ylim([-1.1 1.1]);

% --- FSK Demodulation ---
demodulated_signal = zeros(1, num_bits); % Initialize array for demodulated signal

% Carrier templates for demodulation
carrier1_template = sin(2*pi*fc1*t_bit);
carrier2_template = sin(2*pi*fc2*t_bit);

% Demodulating each bit
for i = 1:num_bits
    % Extract one bit duration segment from the modulated signal
    segment_indices = ((i-1)*samples_per_bit + 1) : (i*samples_per_bit);
    segment_rx = modulated_signal(segment_indices);

% Compute correlation with two carrier frequencies
    % Using sum as approximation of integration (matched filter output)
    cor1 = sum(segment_rx .* carrier1_template);
    cor2 = sum(segment_rx .* carrier2_template);

% Compare correlations to determine demodulated bit
    if cor1 > cor2
        demodulated_signal(i) = 0;
    else
        demodulated_signal(i) = 1;
    end
end

% Plot original and demodulated signals (together for comparison)
subplot(3,1,3); % Changed to 3 subplots
stem(0:num_bits-1, bits, 'filled', 'Marker', 'o', 'Color', 'b', 'DisplayName', 'Original Bits');
hold on;
stem(0:num_bits-1, demodulated_signal, 'filled', 'Marker', 'x', 'Color', 'r', 'DisplayName', 'Demodulated Bits');
title('Original vs. Demodulated Bits');
xlabel('Bit Index');
ylabel('Bit Value');
legend('Location', 'best');
grid on;
axis([-1 num_bits -0.5 1.5]);
hold off;

% Verify accuracy
fprintf('Original Data:     %s\n', num2str(bits));
fprintf('Demodulated Data:  %s\n', num2str(demodulated_signal));
errors = sum(bits ~= demodulated_signal);
fprintf('Number of errors:  %d\n', errors);
web('https://www.salimwireless.com/search?q=FSK%20MATLAB', '-browser');

Output

Fig 2: FSK Modulation and Demodulation

MATLAB Code for PSK Modulation and Demodulation

% The code is written by SalimWireless.Com 
% Clear the workspace, command window, and close all figures
clc;
clear all;
close all;

% Define parameters
carrier_frequency = 10;    % Hz (Increased for better visualization)
bit_duration = 1;       % Bit duration (s)
sampling_frequency = 1000; % Hz
Ts = 1/sampling_frequency; % Sampling interval
samples_per_bit = sampling_frequency * bit_duration; % Number of samples per bit

% Input bit stream
rng(30); % Set random seed for reproducibility
bit_stream = randi([0, 1], 1, 8); % Generate random binary data

% Time vector for one bit duration
t_bit = 0:Ts:bit_duration-Ts;

% --- PSK Modulation ---
psk_signal = []; % Initialize modulated signal array

for bit = bit_stream
    if bit == 0
        % Phase for bit 0 (e.g., 0 radians)
        psk_signal = [psk_signal sin(2*pi*carrier_frequency*t_bit + 0)];
    else
        % Phase for bit 1 (e.g., pi radians)
        psk_signal = [psk_signal sin(2*pi*carrier_frequency*t_bit + pi)];
    end
end

% Overall time vector for plotting modulated signal
t_overall_psk = 0:Ts:(length(bit_stream) * bit_duration) - Ts;

% Plot Original signal
figure;
subplot(3,1,1); % Changed to 3 subplots
stem(0:length(bit_stream)-1, bit_stream, 'filled');
title('Original Binary Information');
xlabel('Bit Index');
ylabel('Bit Value');
grid on;
axis([-1 length(bit_stream) -0.5 1.5]);

% Plot PSK signal
subplot(3,1,2); % Changed to 3 subplots
plot(t_overall_psk, psk_signal);
title('PSK Modulated Signal');
xlabel('Time (s)');
ylabel('Amplitude');
grid on;
ylim([-1.1 1.1]);

% --- PSK Demodulation (Coherent Demodulation) ---
demodulated_psk_data = zeros(1, length(bit_stream));

% Reference carrier for demodulation (0 phase)
reference_carrier = sin(2*pi*carrier_frequency*t_bit);

for i = 1:length(bit_stream)
    % Extract segment for current bit
    segment_indices = ((i-1)*samples_per_bit + 1) : (i*samples_per_bit);
    psk_segment_rx = psk_signal(segment_indices);

% Correlate with reference carrier
    correlation = sum(psk_segment_rx .* reference_carrier);

% Decision device
    % If correlation is positive, it's 0 phase (bit 0). If negative, it's pi phase (bit 1).
    if correlation >= 0
        demodulated_psk_data(i) = 0;
    else
        demodulated_psk_data(i) = 1;
    end
end

% Plot Demodulated data
subplot(3,1,3); % Changed to 3 subplots
stem(0:length(bit_stream)-1, bit_stream, 'filled', 'Marker', 'o', 'Color', 'b', 'DisplayName', 'Original Bits');
hold on;
stem(0:length(bit_stream)-1, demodulated_psk_data, 'filled', 'Marker', 'x', 'Color', 'r', 'DisplayName', 'Demodulated Bits');
title('Original vs. Demodulated PSK Data');
xlabel('Bit Index');
ylabel('Bit Value');
legend('Location', 'best');
grid on;
axis([-1 length(bit_stream) -0.5 1.5]);
hold off;

% Verify accuracy
fprintf('Original Data:     %s\n', num2str(bit_stream));
fprintf('Demodulated Data:  %s\n', num2str(demodulated_psk_data));
errors = sum(bit_stream ~= demodulated_psk_data);
fprintf('Number of errors:  %d\n', errors);
web('https://www.salimwireless.com/search?q=PSK%20MATLAB', '-browser');

Output

Fig 3: PSK Modulation and Demodulation

Search This Blog