MODELLING AND SIMULATION OF TDMA, FDMA AND TDMA FOR
WIRELESS COMMUNICATION
PROGRAM
% Parameters
num_users = 4; % Number of users
num_symbols = 100; % Number of symbols
% Generate random data bits for each user
data_bits = randi([0, 1], num_users, num_symbols);
% TDMA - Time Division Multiple Access
tdma_symbols = zeros(num_users, num_symbols);
for user = 1:num_users
tdma_symbols(user, :) = data_bits(user, :) * 2 - 1; % Convert 0s to -1s and 1s to 1s
end
% FDMA - Frequency Division Multiple Access
fdma_symbols = zeros(num_users, num_symbols);
for user = 1:num_users
fdma_symbols(user, :) = data_bits(user, :) * 2 - 1; % Convert 0s to -1s and 1s to 1s
end
% CDMA - Code Division Multiple Access
% Generating random spreading codes
spreading_codes = randi([0, 1], num_users, num_symbols);
cdma_symbols = zeros(num_users, num_symbols);
for user = 1:num_users
cdma_symbols(user, :) = (data_bits(user, :) * 2 - 1) .* spreading_codes(user, :);
end
% Plot TDMA, FDMA, and CDMA results
t = 1:num_symbols;
figure;
subplot(3, 1, 1);
plot(t, tdma_symbols', 'LineWidth', 1.5);
title('TDMA - Time Division Multiple Access');
xlabel('Symbol Index');
ylabel('Amplitude');
legend('User 1', 'User 2', 'User 3', 'User 4');
subplot(3, 1, 2);
plot(t, fdma_symbols', 'LineWidth', 1.5);
title('FDMA - Frequency Division Multiple Access');
xlabel('Symbol Index');
ylabel('Amplitude');
legend('User 1', 'User 2', 'User 3', 'User 4');
subplot(3, 1, 3);
plot(t, cdma_symbols', 'LineWidth', 1.5);
title('CDMA - Code Division Multiple Access');
xlabel('Symbol Index');
ylabel('Amplitude');
legend('User 1', 'User 2', 'User 3', 'User 4');
sgtitle('Modeling and Simulation of TDMA, FDMA, and CDMA for Wireless Communication');
OUTPUT
WIRELESS CHANNEL EQUALIZATION : ZERO FORCING
EQUALIZER(ZFE),MMSE EQUALIZER(MMSEE),ADAPTIVE
EQUALIZER(ADE),DECISION FEEDBACK EQUALIZER(DFE)
PROGRAM
a) ZERO FORCING EQUALIZER
% Zero Forcing Equalizer Parameters
channel_length = 10; % Length of the channel impulse response
channel_coefficients = [0.2, 0.5, 0.7, 0.3, 0.1, 0.4, 0.8, 0.6,0.9, 0.5]; % Channel coefficients
num_symbols = 1000; % Number of transmitted symbols
SNR_dB = 20; % Signal-to-Noise Ratio in dB
% Generate random data symbols (QPSK modulation)
data_symbols = 2 * randi([0, 1], 1, num_symbols) - 1;
% Apply channel distortion
channel_output = filter(channel_coefficients, 1, data_symbols);
% Add AWGN (Channel Modeling)
noise_power = 10^(-SNR_dB/10);
received_symbols = channel_output + sqrt(noise_power/2)*randn(size(channel_output));
% Zero Forcing Equalization
equalizer_tap = 1 / channel_coefficients(1); % One-tap ZeroForcing Equalizer
equalized_symbols = received_symbols * equalizer_tap;
equalized_bits = sign(equalized_symbols);
num_bit_errors = sum(data_symbols ~= equalized_bits);
bit_error_rate = num_bit_errors / num_symbols;
disp(['Bit Error Rate (BER): ', num2str(bit_error_rate)]);
disp(['SNR (dB):', num2str(SNR_dB)]);
OUTPUT
Bit Error Rate (BER): 0.476
SNR (dB):20
b)MMSE EQUALIZER
% Parameters
M = 4; % Number of transmitted symbols
N = 1000; % Number of received symbols
SNR_dB = 10;
pilot_Symbols = [1 -1 1 -1]; % Known pilot symbols
transmitted_Symbols = randi([0 M-1], 1, N);
modulated_Symbols = qammod(transmitted_Symbols, M);
channel = [0.8 -0.4 0.2 -0.1]; % Example channel coefficients
channel_Output = filter(channel, 1, modulated_Symbols);
SNR = 10^(SNR_dB/10);
noise_Var = 1/(2*SNR);
noise = sqrt(noise_Var) * randn(1, length(channel_Output));
received_Signal = channel_Output + noise;
% Channel estimation using pilot symbols
pilot_Indices = randperm(N, length(pilot_Symbols));
pilot_Signal = received_Signal(pilot_Indices);
estimated_Channel = conv(pilot_Signal, conj(pilot_Symbols(end:-1:1)));
estimated_Channel = estimated_Channel(end-length(channel)+1:end);
% MMSE equalization
equalizer_Coefficients = conj(estimated_Channel) ./ (abs(estimated_Channel).^2 + noise_Var);
equalized_Symbols = filter(equalizer_Coefficients, 1, received_Signal);
Demodulated_Symbols = qamde mod(equalized_Symbols, M);
bit_Errors = sum(transmitted_Symbols ~= demodulated_Symbols);
bit_Error_Rate = bit_Errors / N;
disp(['Bit Error Rate: ' num2str(bit_Error_Rate)]);
OUTPUT
Bit Error Rate: 0.787
C)ADAPTIVE EQUALIZER
% Adaptive Equalization Parameters
channel_length = 10; % Length of the channel impulse response
channel_coefficients = [0.2, 0.5, 0.7, 0.3, 0.1, 0.4, 0.8, 0.6,0.9, 0.5];
num_symbols = 1000; % Number of transmitted symbols
SNR_dB = 20; % Signal-to-Noise Ratio in dB
% Generate random data symbols (QPSK modulation)
data_symbols = 2 * randi([0, 1], 1, num_symbols) - 1;
% Apply channel distortion
channel_output = filter(channel_coefficients, 1, data_symbols);
% Add AWGN (Channel Modeling)
noise_power = 10^(-SNR_dB/10);
received_symbols = channel_output + sqrt(noise_power/2)*randn(size(channel_output));
% Adaptive Equalization using Recursive Least Squares (RLS)algorithm
equalizer_length = channel_length; % Choose equalizer length to be the same as the channel length
delta = 0.01; % Small positive constant to ensure numerical stability
forgetting_factor = 0.99; % Forgetting factor for RLS algorithm
equalizer = zeros(1, equalizer_length); % Initialize equalizer weights
P = (1/delta) * eye(equalizer_length); % Initialize inverse correlation matrix
equalized_symbols = zeros(1, num_symbols); % Store equalized symbols
for i = equalizer_length+1:num_symbols
observation = received_symbols(i:-1:i-equalizer_length+1); % extract current observation window
equalized_output = equalizer * observation.'; % apply equalizer to the observation
error = data_symbols(i) - equalized_output;
K = P * observation.' / (forgetting_factor + observation * P* observation.'); % calculate filter gain
equalizer = equalizer + K.' * error; % update equalizer weights
P = (1/forgetting_factor) * (P - K * observation * P); % update inverse correlation matrix
equalized_symbols(i) = equalized_output; % stored equalized symbol
end
equalized_bits = sign(equalized_symbols;
num_bit_errors = sum(data_symbols ~= equalized_bits);
bit_error_rate = num_bit_errors / num_symbols;
disp(['Bit Error Rate (BER): ', num2str(bit_error_rate)]);
disp(['SNR (dB): ', num2str(SNR_dB)]);
OUTPUT:
Bit Error Rate (BER): 0.449
SNR (dB): 20
D)DECISION FEEDBACK EQUALIZER
% Decision Feedback Equalization Parameters
channel_length = 10; % Length of the channel impulse response
channel_coefficients = [0.2, 0.5, 0.7, 0.3, 0.1, 0.4, 0.8, 0.6,0.9, 0.5]; % Channel coefficients
num_symbols = 1000; % Number of transmitted symbols
SNR_dB = 20; % Signal-to-Noise Ratio in dB
% Generate random data symbols (QPSK modulation)
data_symbols = 2 * randi([0, 1], 1, num_symbols) - 1;
channel_output = filter(channel_coefficients, 1, data_symbols); % apply channel distortion
% Add AWGN (Channel Modeling)
noise_power = 10^(-SNR_dB/10);
received_symbols = channel_output + sqrt(noise_power/2)
*randn(size(channel_output));
% Decision Feedback Equalization
equalizer_length = channel_length; % Choose equalizer length to be the same as the channel length
equalizer = zeros(1, equalizer_length); % Initialize equalizer weights
feedback = zeros(1, equalizer_length); % Initialize feedback coefficients
equalized_symbols = zeros(1, num_symbols); % Store equalized symbols
for i = equalizer_length+1:num_symbols
observation = received_symbols(i:-1:i-equalizer_length+1);
equalized_output = equalizer * observation.' - feedback *equalized_symbols(i-equalizer_length:i-1).';
equalized_symbols(i) = sign(equalized_output);
error = data_symbols(i) - equalized_symbols(i);
equalizer = equalizer + 2 * error * conj(observation);
feedback = feedback + 2 * error * conj(equalized_symbols(i-equalizer_length:i-1));
end
% Calculate Bit Error Rate (BER)
num_bit_errors = sum(data_symbols ~= equalized_symbols);
bit_error_rate = num_bit_errors / num_symbols;
disp(['Bit Error Rate (BER): ', num2str(bit_error_rate)]);
disp(['SNR (dB): ', num2str(SNR_dB)]);
OUTPUT:
Bit Error Rate (BER): 0.498
SNR (dB): 20
