EXP NO - 10

PROGRAM :
WIRELESS CHANNEL SIMULATION INCLUDING FADING AND DOPPLER EFFECTS

% Define Parameters
sampleRate500kHz = 500e3; % Sample rate of 500 KHz
sampleRate20kHz = 20e3; % Sample rate of 20 KHz
maxDopplerShift = 200; % Max Doppler shift of diffuse components (Hz)
delayVector = (0:5:15) * 1e-6; % Discrete delays of 4-path channel (s)
gainVector = [0 -3 -6 -9]; % Average path gains (dB)
KFactor = 10; % Rician K-factor (linear ratio)
specDopplerShift = 100; % Doppler shift of specular component (Hz)

% Configure Rayleigh Channel

rayChan = comm.RayleighChannel( ...
'SampleRate', sampleRate500kHz, ...
'PathDelays', delayVector, ...
'AveragePathGains', gainVector, ...
'MaximumDopplerShift', maxDopplerShift, ...
'RandomStream', 'mt19937ar with seed', ...
'Seed', 10, ...
'PathGainsOutputPort', true);

% Configure Rician Channel

ricChan = comm.RicianChannel( ...
'SampleRate', sampleRate500kHz, ...
'PathDelays', delayVector, ...
'AveragePathGains', gainVector, ...
'KFactor', KFactor, ...
'DirectPathDopplerShift', specDopplerShift, ...
'MaximumDopplerShift', maxDopplerShift, ...
'RandomStream', 'mt19937ar with seed', ...
'Seed', 100, ...
'PathGainsOutputPort', true);

% QPSK Modulator
qpskMod = comm.QPSKModulator( ...
'BitInput', true, ...
'PhaseOffset', pi/4);
% Number of bits per frame
bitsPerFrame = 1000; % 500 symbols per frame for QPSK
msg = randi([0 1], bitsPerFrame, 1); % Generate random bits

% Modulate the message

modSignal = qpskMod(msg);

% Apply Rayleigh and Rician channels

rayChan(modSignal);
ricChan(modSignal);

% Release channels before changing non-tunable properties

release(rayChan);
release(ricChan);

% Enable Impulse and Frequency Response Visualization

rayChan.Visualization = 'Impulse and frequency responses';
rayChan.SamplesToDisplay = '100%';

% Transmit two frames and visualize channel response

numFrames = 2;
for i = 1:numFrames
msg = randi([0 1], bitsPerFrame, 1); % Generate random bits
modSignal = qpskMod(msg); % Modulate data
rayChan(modSignal); % Filter data through Rayleigh channel
end

% Switch to Doppler Spectrum Visualization

release(rayChan); % Release channel before changing properties
rayChan.Visualization = 'Doppler spectrum';

% Transmit 5000 frames to display Doppler spectrum

numFrames = 5000;
for i = 1:numFrames
msg = randi([0 1], bitsPerFrame, 1);
modSignal = qpskMod(msg);
rayChan(modSignal);
end

% Configure Narrowband (Frequency-Flat) Fading

release(rayChan); % Release channel before changing properties
rayChan.Visualization = 'Impulse and frequency responses';
rayChan.SampleRate = sampleRate20kHz;
rayChan.SamplesToDisplay = '25%'; % Display 1 of every 4 samples

% Transmit two frames with frequency-flat fading

for i = 1:numFrames
msg = randi([0 1], bitsPerFrame, 1);
modSignal = qpskMod(msg);
rayChan(modSignal);
end

% Configure Single-Path Fading (Zero Delay)

release(rayChan); % Release channel before changing properties
rayChan.PathDelays = 0;
rayChan.AveragePathGains = 0;

% Transmit two frames with single-path fading

for i = 1:numFrames
msg = randi([0 1], bitsPerFrame, 1);
modSignal = qpskMod(msg);
rayChan(modSignal);
end

% Disable Visualization
release(rayChan);
rayChan.Visualization = 'Off';
release(ricChan);
ricChan.Visualization = 'Off';

% Match Sample Rate and Delays between Rayleigh and Rician Channels
ricChan.SampleRate = rayChan.SampleRate;
ricChan.PathDelays = rayChan.PathDelays;
ricChan.AveragePathGains = rayChan.AveragePathGains;

% Configure Time Scope for Path Gain Visualization

gainScope = dsp.TimeScope( ...
'SampleRate', rayChan.SampleRate, ...
'TimeSpan', bitsPerFrame / (2 * rayChan.SampleRate), ...
'Name', 'Multipath Gain', ...
 'ShowGrid', true, ...
'YLimits', [-40 10], ...
'YLabel', 'Gain (dB)');

% Compare Path Gains from Rayleigh and Rician Channels

msg = randi([0 1], bitsPerFrame, 1);
modSignal = qpskMod(msg);
[~, rayPathGain] = rayChan(modSignal);
[~, ricPathGain] = ricChan(modSignal);

% Display Path Gains on Time Scope

gainScope(10 * log10(abs([rayPathGain, ricPathGain]).^2));
EXP NO - 12
PROGRAM : PULSE SHAPING AND RADIOS (inu mudiyum)

M = 16; % Modulation order

k = log2(M); % Number of bits per symbol
numBits = 3e5; % Number of bits to process
sps = 4; % Number of samples per symbol (oversampling factor)
filtlen = 10; % Filter length in symbols
rolloff = 0.25; % Filter rolloff factor
rrcFilter = rcosdesign(rolloff, filtlen, sps);

fvtool(rrcFilter, 'Analysis', 'Impulse');

rng default; % Use default random number generator
dataIn = randi([0 1], numBits, 1); % Generate vector of binary data
dataInMatrix = reshape(dataIn, length(dataIn) / k, k); % Reshape data into binary 4-tuples
dataSymbolsIn = bi2de(dataInMatrix); % Convert to integers
dataMod = qammod(dataSymbolsIn, M);

txFiltSignal = upfirdn(dataMod, rrcFilter, sps, 1);

EbNo = 10;
snr = EbNo + 10 * log10(k) - 10 * log10(sps);
rxSignal = awgn(txFiltSignal, snr, 'measured');

rxFiltSignal = upfirdn(rxSignal, rrcFilter, 1, sps); % Downsample and filter

rxFiltSignal = rxFiltSignal(filtlen + 1:end - filtlen); % Account for delay

% Bit error rate calculation

dataSymbolsOut = qamdemod(rxFiltSignal, M);
dataOutMatrix = de2bi(dataSymbolsOut, k);
dataOut = dataOutMatrix(:); % Return data in column vector
[numErrors, ber] = biterr(dataIn, dataOut);

fprintf('\nFor an EbNo setting of %3.1f dB, the bit error rate is %5.2e, based on %d errors.\n', ...
EbNo, ber, numErrors);

% Visualize Filter Effects

EbNo = 20;
snr = EbNo + 10 * log10(k) - 10 * log10(sps);
rxSignal = awgn(txFiltSignal, snr, 'measured');
rxFiltSignal = upfirdn(rxSignal, rrcFilter, 1, sps); % Downsample and filter
rxFiltSignal = rxFiltSignal(filtlen + 1:end - filtlen); % Account for delay

eyediagram(txFiltSignal(1:2000), sps * 2);

eyediagram(rxSignal(1:2000), sps * 2);
eyediagram(rxFiltSignal(1:2000), 2);

scatplot = scatterplot(sqrt(sps) * rxSignal(1:sps * 5e3), sps, 0, 'g.');

hold on;
scatterplot(rxFiltSignal(1:5e3), 1, 0, 'kx', scatplot);
title('Received Signal, Before and After Filtering');
legend('Before Filtering', 'After Filtering');
axis([-5 5 -5 5]); % Set axis ranges
hold off;
EXP NO - 13
Program : OFDM SIGNAL TRANSMISSION AND RECEPTION USING SOFTWARE
DEFINED RADIO

%===================================================================
=====
% The mfile investigates the generation, transmission and reception of
% the OFDM signal without channel noise or HPA effect
%===================================================================
=====

clear all;
clc;
close all;

% A: Setting Parameters
M = 4; % QPSK signal constellation
no_of_data_points = 64; % Number of data points
block_size = 8; % Size of each OFDM block
cp_len = ceil(0.1 * block_size); % Length of cyclic prefix
no_of_ifft_points = block_size; % Points for the IFFT
no_of_fft_points = block_size; % Points for the FFT

% B: % +++++ TRANSMITTER +++++

% 1. Generate 1 x 64 vector of data points (phase representations)
data_source = randsrc(1, no_of_data_points, 0:M-1);
figure(1);
stem(data_source);
grid on;
xlabel('Data Points');
ylabel('Transmitted Data Phase Representation');
title('Transmitted Data "O"');

% 2. Perform QPSK modulation

qpsk_modulated_data = pskmod(data_source, M);
figure(2);
scatterplot(qpsk_modulated_data);
title('QPSK Modulated Transmitted Data');
% 3. Do IFFT on each block
% Reshape data into a matrix where each column represents a pre-OFDM block (without cyclic
prefixing)
num_cols = length(qpsk_modulated_data) / block_size;
data_matrix = reshape(qpsk_modulated_data, block_size, num_cols);

% Create empty matrix to store IFFT'd data

cp_start = block_size - cp_len;
cp_end = block_size;

% Operate columnwise & do CP

for i = 1:num_cols
ifft_data_matrix(:, i) = ifft(data_matrix(:, i), no_of_ifft_points);

% Compute and append Cyclic Prefix

for j = 1:cp_len
actual_cp(j, i) = ifft_data_matrix(j + cp_start, i);
end

% Append the CP to create the actual OFDM block

ifft_data(:, i) = vertcat(actual_cp(:, i), ifft_data_matrix(:, i));
end

% 4. Convert to serial stream for transmission

[rows_ifft_data, cols_ifft_data] = size(ifft_data);
len_ofdm_data = rows_ifft_data * cols_ifft_data;

% Actual OFDM signal to be transmitted

ofdm_signal = reshape(ifft_data, 1, len_ofdm_data);
figure(3);
plot(real(ofdm_signal));
xlabel('Time');
ylabel('Amplitude');
title('OFDM Signal');
grid on;

% E: % +++++ RECEIVER +++++

% 1. Pass the OFDM signal through the channel
recvd_signal = ofdm_signal; % Here you could implement a channel model
% 4. Convert Data back to "parallel" form to perform FFT
recvd_signal_matrix = reshape(recvd_signal, rows_ifft_data, cols_ifft_data);

% 5. Remove CP
recvd_signal_matrix(1:cp_len, :) = []; % Remove the cyclic prefix

% 6. Perform FFT
for i = 1:cols_ifft_data
fft_data_matrix(:, i) = fft(recvd_signal_matrix(:, i), no_of_fft_points);
end

% 7. Convert to serial stream

recvd_serial_data = reshape(fft_data_matrix, 1, (block_size * num_cols));

% 8. Demodulate the data

qpsk_demodulated_data = pskdemod(recvd_serial_data, M);

% Plotting the received data

figure(4);
scatterplot(qpsk_demodulated_data);
title('QPSK Modulated Received Data');

figure(5);
stem(qpsk_demodulated_data, 'rx');
grid on;
xlabel('Data Points');
ylabel('Received Data Phase Representation');
title('Received Data "X"');
EXP NO - 11
Program:

SIMULATION OF CHANNEL ESTIMATION, SYNCHRONIZATION AND EQUALIZATION

TECHNIQUES

% LTE Parameters
enb.NDLRB = 15; % Number of resource blocks
enb.CellRefP = 1; % One transmit antenna port
enb.NCellID = 10; % Cell ID
enb.CyclicPrefix = 'Normal'; % Normal cyclic prefix
enb.DuplexMode = 'FDD'; % FDD
SNRdB = 22; % Desired SNR in dB
SNR = 10^(SNRdB/20); % Linear SNR
rng('default'); % Configure random number generators
cfg.Seed = 1; % Channel seed
cfg.NRxAnts = 1; % 1 receive antenna
cfg.DelayProfile = 'EVA'; % EVA delay spread
cfg.DopplerFreq = 120; % 120Hz Doppler frequency
cfg.MIMOCorrelation = 'Low'; % Low (no) MIMO correlation
cfg.InitTime = 0; % Initialize at time zero
cfg.NTerms = 16; % Oscillators used in fading model
cfg.ModelType = 'GMEDS'; % Rayleigh fading model type
cfg.InitPhase = 'Random'; % Random initial phases
cfg.NormalizePathGains = 'On'; % Normalize delay profile power
cfg.NormalizeTxAnts = 'On'; % Normalize for transmit antennas

% Channel Estimation Configuration

cec.PilotAverage = 'UserDefined'; % Pilot averaging method
cec.FreqWindow = 9; % Frequency averaging window in REs
cec.TimeWindow = 9; % Time averaging window in REs
cec.InterpType = 'Cubic'; % Cubic interpolation
cec.InterpWinSize = 3; % Interpolate up to 3 subframes simultaneously
cec.InterpWindow = 'Centred'; % Interpolation windowing method

% Resource Grid Size

gridsize = lteDLResourceGridSize(enb);
K = gridsize(1); % Number of subcarriers
L = gridsize(2); % Number of OFDM symbols in one subframe
P = gridsize(3); % Number of transmit antenna ports

% Initialize Variables
txGrid = []; % Transmit Resource Grid

% Number of bits needed

numberOfBits = K * L * P * 2; % Number of bits (size of resource grid * bits per symbol)

% Create random bit stream

inputBits = randi([0 1], numberOfBits, 1);

% Modulate input bits

inputSym = lteSymbolModulate(inputBits, 'QPSK');

% Generate Subframes
for sf = 0:10
% Set subframe number
enb.NSubframe = mod(sf, 10);

% Generate empty subframe

subframe = lteDLResourceGrid(enb);

% Map input symbols to grid

subframe(:) = inputSym;

% Generate synchronizing signals

pssSym = ltePSS(enb);
sssSym = lteSSS(enb);
pssInd = ltePSSIndices(enb);
sssInd = lteSSSIndices(enb);

% Map synchronizing signals to the grid

subframe(pssInd) = pssSym;
subframe(sssInd) = sssSym;

% Generate cell specific reference signal symbols and indices

cellRsSym = lteCellRS(enb);
cellRsInd = lteCellRSIndices(enb);

% Map cell specific reference signal to grid

 subframe(cellRsInd) = cellRsSym;

% Append subframe to grid to be transmitted

txGrid = [txGrid subframe]; %#ok
end

% OFDM Modulation
[txWaveform, info] = lteOFDMModulate(enb, txGrid);
txGrid = txGrid(:, 1:140);
cfg.SamplingRate = info.SamplingRate;

% Pass data through the fading channel model

rxWaveform = lteFadingChannel(cfg, txWaveform);

% Calculate noise gain

N0 = 1 / (sqrt(2.0 * enb.CellRefP * double(info.Nfft)) * SNR);

% Create additive white Gaussian noise

noise = N0 * complex(randn(size(rxWaveform)), randn(size(rxWaveform)));

% Add noise to the received time domain waveform

rxWaveform = rxWaveform + noise;

% Frame Offset Correction

offset = lteDLFrameOffset(enb, rxWaveform);
rxWaveform = rxWaveform(1 + offset:end, :);
rxGrid = lteOFDMDemodulate(enb, rxWaveform);
enb.NSubframe = 0;

% Channel Estimation
[estChannel, noiseEst] = lteDLChannelEstimate(enb, cec, rxGrid);
eqGrid = lteEqualizeMMSE(rxGrid, estChannel, noiseEst);

% Calculate error between transmitted and equalized grid

eqError = txGrid - eqGrid;
rxError = txGrid - rxGrid;

% Compute EVM across all input values

EVM = comm.EVM;
EVM.AveragingDimensions = [1 2];
preEqualisedEVM = EVM(txGrid, rxGrid);
fprintf('Percentage RMS EVM of Pre-Equalized signal: %0.3f%%\n', preEqualisedEVM);

% EVM of post-equalized receive signal

postEqualisedEVM = EVM(txGrid, eqGrid);
fprintf('Percentage RMS EVM of Post-Equalized signal: %0.3f%%\n', postEqualisedEVM);

% Plot the received and equalized resource grids

figure;
subplot(1, 2, 1);
imagesc(abs(rxGrid));
title('Received Grid');
xlabel('Subcarriers');
ylabel('OFDM Symbols');
colorbar;

subplot(1, 2, 2);
imagesc(abs(eqGrid));
title('Equalized Grid');
xlabel('Subcarriers');
ylabel('OFDM Symbols');
colorbar;