ELEC6141 August 15, 2014
WIRELESS COMMUNICATION
PROJECT REPORT
Prepared by
Gurjot Singh (ID: 7144628)
Vivek Kumar (ID: 7182422)
Maanvir Sidhu (ID: 6988474)
Instructor: Dr. Yousef R. Shayan
“We certify that this submission is the original work of members of the group and
Meets the Faculty's Expectations of Originality”
Department of Electrical and Computer EngineeringPage 1
ELEC6141 August 15, 2014
Abstract
In this report we will be discussing the 16-QAM (Quadrature amplitude Modulation) Communication system. We will determine the Bit Error Rate (BER) performance of 16-QAM scheme over AWGN channels with and without coding (Gray Coding). System performance will be evaluated on the bases of simulated data compared to theoretical data. Fading is also considered in this 16-QAM system with the Doppler Spread due to mobile movement in the channel. Simulation for the BER will be done with the mobile moving at certain speed without using any equalization scheme. Later we will discuss about the improvement in the coded performance of the system by introducing an inter-leaver.
Keywords:16QAM System, Hamming code (15, 11), Rayleigh fading, Interleaver.
1. INTRODUCTION
Quadrature Amplitude Modulation (QAM) is both analog and digital modulation scheme which transmits two analog or digital bit streams by modulating the amplitudes of two carrier waves, using amplitude shift keying and amplitude modulation scheme[1].
QAM signal is implemented by mixing two sine waves which are 90 degrees out of phase with one another. One signal is called I_signal and the other one Q_signal. These carriers are combined together during transmitting process and the carriers are separated and information is extracted from each carrier at the receiver side. For detection and correction of errors, we use Hamming code. Hamming codes are a family of linear error-correcting codes [2], we have used [15, 11] hamming code which can detect and correct up to two bit errors.
We are also using an Interleaver to improve the overall system performance. The primary purpose of the Interleaver is to read and write the data out of sequence involving forward error correction coding. The coded data (bits of codeword’s) gets Interleaved(scrambled) before modulation and then transmitted.At the receiver side after demodulation, received bit is de-interleaved.
2. UNCODED 16QAM SYSTEM
2.1 Background
In a Digital Communication System, Quadrature Amplitude Modulation (QAM) is a digital modulation scheme that conveys data by changing, or modulating the some aspect of a carrier signal or the carrier wave. As shown in block diagram Figure2.1, first we generate input bits, and then these bits are divided into a matrix of four rows in mapping [3]. The Mapper output then goes into a channel where AWGN (Additive White Noise) is added to signal. The signal with AWGN noise is delivered to detector. Lastly, the initial input and the output of detector are compared to find BER.
Figure 2.1 Base band Model for uncoded system
2.3Finding the Bit Error Rate
2.3.1 Simulated and Theoretical Calculation
The simulated bit error rate is obtained by comparing input data and output data using the exclusive OR function giving us the difference between the generated data and the received data. After that, we find the number of errors occurred by counting the number of different bits.
Therefore the probability of bit error, (where M= L^2) is given by:
2.4 Plotting Theoretical and Simulated BER
We represent the simulated BER with BLUEcolor and theoretical BER with GREEN color as shown in Figure 2.2
Figure 2.2 Plot of BER vs Eb/No (dB) for uncoded 16QAM
3. CODED 16QAM SYSTEM
3.1 Background
The Coded 16QAM system is same as the uncoded 16QAM, but with two extra blocks. The encoder block. before the mapper and the decorder block after the detector as shown in Figure 3.1.
Figure 3.1 System Model for Coded 16 QAM
We use (15,11) hamming code as the coding channel of the system, where n = 15 and k = 11.
The channel Bit Error Probability (Pc) of the uncoded 16QAM system is:
Formula of theoretical BER is:
In our simulation we are dividing the input bits into N/11 messages of 11 bits each. In the encoder, the generator matrix is generated using the parity check matrix.
Thus, generator matrix can be written as:
3.2Simulated and Theoretical Bit Error Rate
To find the simulated bit error rate, the output of decoder is entered to the comparator where it is compared with the 11 bit message inputs. Then by comparing input data and output data using the exclusive OR function, we get thedifference between the generated data and the received data.
3.3 Plotting the Theoretical and Stimulated BER
We represent the simulated BER for coded 16QAM by GREEN and theoretical BER of Coded 16QAM by BLUE as shown in Figure 3.2
Figure 3.2 Plot of BER vs Eb/No for 16QAM with Coding
4. 16QAM WITH RAYLEIGH FADING
4.1 Background
Doppler spread causes channel fading, which we will consider in this system. The type of fading (Slow or Fast) is evaluated after calculating Coherence time(Tc) and Symbol period (Ts) and we compare them.
Value of Ts= 2µs, to find Tc we need to calculate Doppler spread (fm) first.
By comparing Tc and Ts, we find that Ts<Tc which means we have slow fading in the channel and the channel will change after each Tc seconds or after each 450 bits.
Figure 4.1 Rayleigh Fading
We use Rayleigh distribution to introduce fading effect as shown in Figure 4.1. The probability density function of Rayleigh distribution is given as:
4.2 Theoretical and Simulated Bit Error Rate (BER)
The simulation for both Coded and Uncoded systems with fading is done in the similar way.
4.3 Plotting Theoretical and Simulated BER
The BER for Rayleigh fading and AWGN channel for 16QAM uncoded is shown in Figure 4.1 and coded in Figure 4.2 respectively.
Figure 4.1 Rayleigh fading channel for 16QAM without coding
Figure4.2 Coded information of Rayleigh fading channel for 16 QAM
5. 16QAM CODED SYSTEM WITH INTERLEAVER
5.1 Background
An Interleaver is used to improve the overall system performance. The primary purpose of the Interleaver is to read and write the data out of sequence involving forward error correction coding. The coded data (bits of codeword’s) gets interleaved (scrambled) before modulation and then transmitted as shown in Figure 5.1
Figure 5.1 Interleaving
At the receiver side after demodulation, received bits are de-interleaved as shown in Figure 5.2.
Figure 5.2 De-Interleaver
During transmission, bits in the same codeword are separated by d-1 other bits/symbols. Bits in the same codeword experiences independent fading if the separation in time is greater than the channel coherence time (Tc).Deep Interleaver happens when the condition dTb-coded >Tc is satisfied, where d is the depth of the Interleaver.
In Interleaver, the data which is a matrix of n/11 with 15 bits will be read by columns instead of reading it by rows.
After the demodulator, the data is read by columns and the result will be the same matrix of n/11 rows and 15 columns. The output enters into the comparator where it is compared with the inputs using XOR function. The average bit error rate is then calculated and sketched versus Eb/No.
5.2 Plotting the theoretical and simulated bit error rate
The Figure 5.2 shows Rayleigh fading coded and uncoded system along with the Interleaver.
Figure 5.2 Coded systems in Rayleigh fading with Interleaver
6. CONCLUSION
Comparedto the Uncoded and the coded systems, we found that the Bit Error Rate versus Eb/N0 of the coded system is better than the uncoded system for the same SNR i.e. by reducing the SNR to improve the reliability of the system we get a better result. Whereas in the case of faded and unfaded for both coded and uncoded system we found that due to slow fading in the channel the signal undergoes large distortion. In general, we need SNR to be much smaller than the needed SNR in the case of slow fading which is not a practical solution. Thus, there are various methods to solve the fading problem such as by using OFDM system and equalization filters.
While comparing the Rayleigh fading in the uncoded and coded system we observe that the performance of the coded system is worse than Uncoded system since all the bits of one codeword have the same fading coefficient. In the case of the deep fading, all the codeword are corrupted while (15,11) BCH code can correct only 1 bit error in each 15 bits. Thus this code would add even more errors and the performance gets worse.
Finally, after comparing the entire system with and without Interleaver we could observe that the difference between both of them appears because bits in the same codeword experience independent fading due to the greater separation in time compared to the channel coherence time.
ACKNOWLEDGEMENT
We take this opportunity to express my profound gratitude and deep regards to my guide Professor DR. YOUSEF R. SHAYAN for his exemplary guidance, monitoring and constant encouragement throughout the course.
The constructive efforts in this project, however, would not have been possible without the kind of support and help given by our project tutor Mr. Sepehr Khodadadi. His cordial support, valuable information and guidance helped me in completing this task through various stages.
References
[1]
[2] "Digital Communications Fundamentals and Applications”, 2nd edition, Bernard Sklar".
[3] “Introduction to Wireless Systems”, Prentice Hall, 2008, Bruce A. Black et al
[4] "Communication Systems 4Th Edition Simon Haykin".
APPENDIX: MATLAB CODE
PART A
clc;
clear all; % clear screen
No_of_Bits =19800;% number of bits
random_variable_gen = rand(1,No_of_Bits); %generate random values
%Assumption
%Eb=1
% M=16 .... 16 QAM uncoded ... number of constellation points
d=sqrt(10)/5; % Es = 10*d*d (Assumption)
%Generating random data
Binary_data= round(random_variable_gen); % rounding the random_variable to 0's and 1's
X_channel_data = Binary_data(1:4:No_of_Bits); %X branch data -- ODD bits
Y_channel_data = Binary_data(2:4:No_of_Bits); %Y branch data -- EVEN bits
Z_channel_data = Binary_data(3:4:No_of_Bits); %Z branch data -- ODD bits
W_channel_data = Binary_data(4:4:No_of_Bits); %W branch data -- EVEN bits
I_Mapper_data = d*((2.*Y_channel_data)-1).*(3.*(not(W_channel_data))+W_channel_data); % Mapping the I channel data "0" to "-1" and "1" to "+1"
Q_Mapper_data = d*((2.*X_channel_data)-1).*(3.*(not(Z_channel_data))+Z_channel_data); % Mapping the Q channel data "0" to "-1" and "1" to "+1"
%I_Mapper_data = 2*X_channel_data - 1 ; % Mapping the I channel data "0" to "-1" and "1" to "+1"
%Q_Mapper__data = 2*Y_channel_data - 1 ; % Mapping the Q channel data "0" to "-1" and "1" to "+1"
Combined_mapped_data= I_Mapper_data+j* Q_Mapper_data; % will have the data in form of either (+/-)1 (+/-)j 1, (+/-)1(+/-)j3, (+/-)3(+/-)j1, (+/-)3(+/-)j3
SNR_simulated = 0:1:10; %simulated signal to noise ratio
for i=1:length(SNR_simulated);
No = power(10,-(SNR_simulated(i)/10)); %defining the noise spectral density No
%Generating AWGN noise
noise= randn(1, No_of_Bits/4);
I_channel_noise= (sqrt(No/2))* noise; % real part of noise in I channel
Q_channel_noise = (sqrt(No/2))* noise; % imaginary part of noise in Q channel
Combined_Noise = I_channel_noise +j* Q_channel_noise;
Data_Received = Combined_mapped_data + Combined_Noise; % received signal in Receiver side
Data_received_I = real(Data_Received); %I component of received data
Data_received_Q = imag(Data_Received); % Q component of received data
%Decoding
% sepaprationg of X, Y, Z, W component of received data
X_channel_decoded_data =(sign(Data_received_Q)+1)/2;
Y_channel_decoded_data =(sign(Data_received_I)+1)/2;
Z_channel_decoded_data =(sign(abs(Data_received_Q)-2*d)-1)/(-2);
W_channel_decoded_data =(sign(abs(Data_received_I)-2*d)-1)/(-2);
%Combining X, Y, Z, W data together
Combined_decoded_data(1:1:No_of_Bits)= 0;
Combined_decoded_data(1:4:No_of_Bits)= X_channel_decoded_data ;
Combined_decoded_data(2:4:No_of_Bits)= Y_channel_decoded_data ;
Combined_decoded_data(3:4:No_of_Bits)= Z_channel_decoded_data ;
Combined_decoded_data(4:4:No_of_Bits)= W_channel_decoded_data ;
signal_Rx= round(Combined_decoded_data);
%Checking error and measuring number of errors
Error_check= xor(Binary_data,signal_Rx);
Num_of_Errors(i) = sum(Error_check);
end
Simulated_BER= Num_of_Errors /No_of_Bits; % simluated value of Bit Error rate
%Theoretical simulation of 16 QAM
SNR_theoretical = 0:1:10;
for i=1:1:length(SNR_theoretical);
Theoretical_BER= (3/8)*erfc(sqrt((2/5)*power(10,SNR_theoretical/10)));
end
%======BIT ERROR RATE FIGURE======%
figure
subplot(2,1,1);
semilogy(SNR_simulated,Simulated_BER,'b--*');
title('Simulated Bit Error Rate (BER)for 16 QAM');
xlabel('Eb/No (in dB)');
ylabel('Bit error rate (BER)');
grid on;
subplot(2,1,2);
semilogy(SNR_theoretical,Theoretical_BER,'g--o');
hold on;
grid on;
title('Theoretical Bit Error Rate (BER)for 16 QAM');
xlabel('Eb/No (in dB)')
ylabel('Bit error rate (BER)');
figure
semilogy(SNR_simulated,Simulated_BER,'b--*');
hold on;
grid on;
semilogy(SNR_theoretical,Theoretical_BER,'g--o');
title('Simulation of uncoded 16 QAM');
legend('Simulation','Theoretical');
xlabel('Eb/No (in dB)');
ylabel('Bit error rate (BER)');
PART B
close all;
clear all;
clc;
%Parameters
n=15; %Codeword Bit as n
k=7; %Information Bit as k
t=2; %Error Correction Bit as t
%Parity Matrix of G_sys (generator matrix) where number of column is n-k
P=[ 1 0 0 0 1 0 1 1
1 1 0 0 1 1 1 0
0 1 1 0 0 1 1 1
1 0 1 1 1 0 0 0
0 1 0 1 1 1 0 0
0 0 1 0 1 1 1 0
0 0 0 1 0 1 1 1];
Identity_G=diag(ones(1,k)); %Identity matrix of G_sys (Generator matrix)
G=[P Identity_G]; % generator matrix
Identity_H=diag(ones(1,n-k)); %Identity matrix of H (Parity check matrix)
H=[Identity_H P']; %Parity check matrix
%Preparing the error pattern matrix
error_pat_matrix=diag(ones(1,n));
Increment_counter=0;
for i=1:n-1
for jj=i+1:n
Increment_counter=Increment_counter+1;
error_pat_matrix(n+Increment_counter,:)=error_pat_matrix(i,:)+error_pat_matrix(jj,:);
end
end
b=zeros(1,n);
Error_Pattern=[b' error_pat_matrix']';
Syndrome_mat=mod(Error_Pattern*H',2); %S is syndrome
Comparison_Table=horzcat(Error_Pattern,Syndrome_mat);
Error_Pattern_Number=121;
%Assumptions
%Eb = 1; %Bit energy
%M = 16; % 16 QAM Constellation Size
%k = log2(M); %Number of bits per symbol
%Es = k*Eb ; % Symbol Energy
%Es=10*d*d;
d = sqrt(10)/5; % Assumption
NumOfBits =4200;% number of bits to transmit
Counter = 0;
for SNRindb=0:1:11;
Counter=Counter+1;
Number_Of_Error(Counter)=0;
Eb_No(Counter)=SNRindb;
Total_Num_Of_Bits=0;
while Number_Of_Error(Counter)<30
Total_Num_Of_Bits=Total_Num_Of_Bits+NumOfBits;
%Generation of Data to be transmitted
Data_Tx_Gen = round(rand(1,NumOfBits));
%Reorganize the data , make a matrix whose each row has 7 data
for num=1:NumOfBits/k
Data_Tx_k(num,:)=Data_Tx_Gen((num-1)*k+1:(num*k));
end
%Data_Tx_Matrix_n=mod(Data_Tx_Matrix_k*G,2);
Data_Tx_Matrix_n=mod(Data_Tx_k*G,2);% transfer to new matrix with 15 column
% each row represent data as codewords
Binary_Data_Tx=[];
%transfer all rows to single row
for num=1:NumOfBits/k
Data_Rearrange=Data_Tx_Matrix_n(num,:);
Binary_Data_Tx=[Binary_Data_Tx Data_Rearrange];
end
NumOfBitsCoded=NumOfBits*n/k;
Tx_x = Binary_Data_Tx(1:4:NumOfBitsCoded); %x-component
Tx_y = Binary_Data_Tx(2:4:NumOfBitsCoded); %y-component
Tx_z = Binary_Data_Tx(3:4:NumOfBitsCoded); %z-component
Tx_w = Binary_Data_Tx(4:4:NumOfBitsCoded); %w-component
% I component of modulated signal for 16QAM
Data_Tx_Modulated_I = d*((2.*Tx_y)-1).*(3.*(not(Tx_w))+Tx_w);
% Q component of modulated signal for 16QAM
Data_Tx_Modulated_Q = d*(2.*Tx_x - 1).*(3.*(not(Tx_z))+Tx_z);
% Prepare the Modulated signal to be transmitted
Data_Tx_Modulated = Data_Tx_Modulated_I +sqrt(-1)*Data_Tx_Modulated_Q;
%AWGN generation for 16 QAM
Sigma2 = (n/k)*0.5*10^(-Eb_No(Counter)/10); %Variance (Sigma squared) of Noise
Noise_Real=sqrt(Sigma2)*randn(1,(NumOfBitsCoded/4));
Noise_Imag=sqrt(Sigma2)*randn(1,(NumOfBitsCoded/4));
Noise=Noise_Real+sqrt(-1)*Noise_Imag;
% Addition of white noise to the signal
Data_Rx = Data_Tx_Modulated + Noise; % Received signal in Rx side
Data_Rx_Real = real(Data_Rx); % I component of received Data
Data_Rx_Imag = imag(Data_Rx); % Q component of received Data
%Seperating x y z & w component of received data as 16 QAM is used for modulation
Rx_x = (sign(Data_Rx_Imag) + 1)/2 ;
Rx_y = (sign(Data_Rx_Real) + 1)/2;
Rx_z =(sign(abs(Data_Rx_Imag) - 2*d) - 1)/(-2);
Rx_w = (sign(abs(Data_Rx_Real) - 2*d) - 1)/(-2);
% Arrenging the received Data bit or streem
Esimated_Data_Rx(1:1:NumOfBitsCoded)=0;
Esimated_Data_Rx(1:4:NumOfBitsCoded)=Rx_x;
Esimated_Data_Rx(2:4:NumOfBitsCoded)=Rx_y;
Esimated_Data_Rx(3:4:NumOfBitsCoded)=Rx_z;
Esimated_Data_Rx(4:4:NumOfBitsCoded)=Rx_w;
%From the received bit stream taking n number of bit at a time and
%find the error sybdrom and find the corresponding syndrom from the
%table and find the corrected bit.
for num=1:NumOfBits/k
r=Esimated_Data_Rx((num-1)*n+1:num*n);
Syn_rht=r*H';
Syn_rht=mod(Syn_rht,2);
for m=1:Error_Pattern_Number
if Syn_rht==Comparison_Table(m,n+1:n+k+1) % Comparing with syndrom table
r=r+Comparison_Table(m,1:n);
r=mod(r,2);
rr=r(k+2:n);
else
rr=r(k+2:n); % if can't match S, which means bit error over 2
end
end
%Finding the number of error
Errors=xor(rr,Data_Tx_k(num,:));
Number_Of_Error(Counter)=sum(Errors)+Number_Of_Error(Counter) ;
end
end
%Calculation of simulated bit error rate
Simulated_BER(Counter)= Number_Of_Error(Counter)/Total_Num_Of_Bits % The Bit Error Rate BER
%calculation of theoretical bit error rate
EBNO=(k/n)*10^(Eb_No(Counter)/10);
Pc=(3/4)*(1/2)*erfc(sqrt((4/10)*EBNO));
Pb=0;
for jj=t+1:n
Pb(jj)= jj*(factorial(n)/(factorial(jj)*factorial(n-jj)))*(Pc^jj)*(1-Pc)^(n-jj);
end
Theoretical_BER(Counter) =sum(Pb)/n;
end
semilogy(Eb_No,Simulated_BER,'g--*'); % Plot the simulated results.
axis([0.01 12 10^(-6) 10^(-0)]);
hold on;
semilogy(Eb_No,Theoretical_BER,'b--o'); % Plot the theoretical results.
hold on;
xlabel('Eb/No (dB)');
ylabel('Bit Error Rate (BER)');
title('Theoretical and Simulated Bit Error Rate (BER) for 16 QAM with Coding');
legend('Simulated BER(Coded)','Theoretical BER(Coded)');
grid on;
PART C
clear all;
close all;
clc;
%Assumptions
Eb = 1; %bit energy
%Es = 4; %symbol energy
d = (sqrt(10))/5; % Assumption
%Given
%Rb=2*(10^6);% Information rate 2Mb/s;
%Fc=12*(10^9); % Carrier frequency 12GHz
%V=(42.3*(10^3))/3600; %Speed 42.3Km/Hour
%Tc=380.95*(10^(-6));% Coherence time of the channel
%Ts=2*(10^(-6)); %Symbol rate
Tc_by_Ts=191; %Number of symbol in one block of slow fading
Num_Of_Bits=4*191*7; %nummber of input bits
Counter=0;
for SNR=0:3:18;
Total_No_Of_Bits=0;
Counter=Counter+1; % Used as Index or Counter
Eb_No(Counter)=SNR;
Total_Error=0;
while Total_Error<1000
Total_No_Of_Bits=Total_No_Of_Bits+Num_Of_Bits;
%Generation of Data to be transmitted
Data_Tx=round(rand(1,Num_Of_Bits));
% Seperating x y z & w component of data for 16 QAM Modulation
x_channel_data = Data_Tx(1:4:Num_Of_Bits);
y_channel_data = Data_Tx(2:4:Num_Of_Bits);
z_channel_data = Data_Tx(3:4:Num_Of_Bits);
w_channel_data = Data_Tx(4:4:Num_Of_Bits);
% I component of modulated signal for 16QAM
Data_Tx_I_channel = d*(((2.*y_channel_data) - 1).*(3.*(not(w_channel_data))+w_channel_data));
% Q component of modulated signal for 16QAM
Data_Tx_Q_channel = d*(((2.*x_channel_data) - 1).*(3.*(not(z_channel_data))+z_channel_data));
% Prepare the Modulated signal to be transmitted
Combined_Data_Tx = Data_Tx_I_channel + j*Data_Tx_Q_channel; %this will make the sent signal as complet number
%AWGN generation for 16 QAM
AWGN_noise = 0.5*10^(-(Eb_No(Counter))/10); %Variance of AWGN Noise
Noise_Real_component=sqrt(AWGN_noise)*randn(1,(Num_Of_Bits/4));
Noise_Imag_component=sqrt(AWGN_noise)*randn(1,(Num_Of_Bits/4));
Combined_Noise=Noise_Real_component+Noise_Imag_component*sqrt(-1);
%Rayleigh fadding generation for 16 QAM
Rayleigh_Real_component=sqrt(1/2)*randn(1,Num_Of_Bits/Tc_by_Ts);
Rayleigh_Imag_component=sqrt(1/2)*randn(1,Num_Of_Bits/Tc_by_Ts);
Rayleigh_combined =Rayleigh_Real_component+j*Rayleigh_Imag_component;
% Addition of Rayleigh fadding effect
Signal_Rayleigh_Faded= [];
for i= 1:Num_Of_Bits/(4*Tc_by_Ts)
BlockOfSignal_RayleighFaded = Rayleigh_combined(i)*Combined_Data_Tx(((i-1)*Tc_by_Ts)+1:(i*Tc_by_Ts));
Signal_Rayleigh_Faded = [Signal_Rayleigh_Faded,BlockOfSignal_RayleighFaded];
end
% Addition of white noise to the signal
Data_Rx_Rayleigh_AWGN = Signal_Rayleigh_Faded + Combined_Noise;
%Removing Rayleigh fading effect
Data_Rx = [];
for i = 1:Num_Of_Bits/(4*Tc_by_Ts)
Block_Data_Rx = Data_Rx_Rayleigh_AWGN(((i-1)*Tc_by_Ts)+1:(i*Tc_by_Ts))/Rayleigh_combined(i);
Data_Rx = [Data_Rx,Block_Data_Rx];
end
Data_Rx_Real_component= real(Data_Rx); %I part of the recived signal
Data_Rx_Imag_component= imag(Data_Rx); %Q part of the recived signal
%Seperating x y z & w component of received data
Rx_x_channel_data = (sign(Data_Rx_Imag_component) + 1)/2 ;
Rx_y_channel_data = (sign(Data_Rx_Real_component) + 1)/2;
Rx_z_channel_data =(sign(abs(Data_Rx_Imag_component) - 2*d) - 1)/(-2);
Rx_w_channel_data = (sign(abs(Data_Rx_Real_component) - 2*d) - 1)/(-2);
% Arrenging the received Data bit or streem
Esimated_Data_Rx(1:1:Num_Of_Bits)=0;
Esimated_Data_Rx(1:4:Num_Of_Bits)=Rx_x_channel_data;
Esimated_Data_Rx(2:4:Num_Of_Bits)=Rx_y_channel_data;
Esimated_Data_Rx(3:4:Num_Of_Bits)=Rx_z_channel_data;
Esimated_Data_Rx(4:4:Num_Of_Bits)=Rx_w_channel_data;
%Comparing the Tx and Rx Data
Error=xor(Esimated_Data_Rx,Data_Tx); %this will find the errors
Total_Error=Total_Error+sum(Error);
end
%Calculation of Simulated BER
Simulated_BER(Counter)=Total_Error/Total_No_Of_Bits %this will calculate the probilty of bit errors rate
%Calculation of theoretical BER
EBNO(Counter)=10.^(Eb_No(Counter)/10);
Theoretical_BER(Counter)=(3/4)*(1/2)*erfc(sqrt(4/5*EBNO(Counter))/(2^0.5));
end
semilogy(Eb_No,Simulated_BER,'b--*')
axis([0.01 18 10^(-14) 10^(-0)]);
hold on
semilogy(Eb_No,Theoretical_BER,'g--o');
hold on
xlabel('Eb/No (dB)');
ylabel('Bit Error Rate (BER)');
title('Rayleigh fading Channel for 16 QAM Without Coding');
legend('BER for Rayleigh fading channel(Simulated)','BER for AWGN Channel(Theoretical)','Location','SouthEast');
grid on;
PART D
clear all;
close all;
clc;
%Parameters
n=15; %Codeword Bit as n
k=7; %Information Bit as k
t=2; %Error Correction Bit as t
%Parity Matrix of G_sys (generator matrix) where number of column is n-k
P =[ 1 0 0 0 1 0 1 1
1 1 0 0 1 1 1 0
0 1 1 0 0 1 1 1
1 0 1 1 1 0 0 0
0 1 0 1 1 1 0 0
0 0 1 0 1 1 1 0
0 0 0 1 0 1 1 1];
%Identity matrix of G_sys (Generator matrix)
Identity_G=diag(ones(1,k));
G=[P Identity_G];
%Identity matrix of H (Parity check matrix)
Identity_H=diag(ones(1,n-k));
%Parity check matrix
H=[Identity_H P'];
%Preparing the error pattern matrix
error_pattern_mat=diag(ones(1,n));
Increment_counter=0;
for i=1:n-1
for jj=i+1:n
Increment_counter=Increment_counter+1;
error_pattern_mat(n+Increment_counter,:)=error_pattern_mat(i,:)+error_pattern_mat(jj,:);
end
end
b=zeros(1,n);
Error_Pattern=[b' error_pattern_mat']';
S=mod(Error_Pattern*H',2); %S is syndrome
Comparison_Table=horzcat(Error_Pattern,S);
Error_Pattern_Number=121;
Eb = 1; % We Assume that the energy per bit is 1
Es = 4 ; % Energy per symbol
%M = 16; %Constellation Size - 16-QAM
%k = log2(M); %Number of bits per symbol
%Given
%Rb=2*(10^6);% Information rate 2Mb/s;
%Fc=12*(10^9); % Carrier frequency 12GHz
%V=(42.3*(10^3))/3600; %Speed 42.3Km/Hour
%Tc=380.95*(10^(-6));% Coherence time of the channel
%Ts=2*(10^(-6)); %Symbol rate
Tc_by_Ts=191; %Number of symbol in one block of slow fading
d = sqrt(10)/5;
Num_Of_Bits=4*191*7;%nummber of input bits
Counter=0;
for SNR=0:3:18;
Total_No_OfBits=0;
Counter=Counter+1; % Used as Index or Counter
EbNo(Counter)=SNR;
Total_Error=0;
Number_of_Error_Coded=0;
while Total_Error<1000
Total_No_OfBits=Total_No_OfBits+Num_Of_Bits;
Binary_Data_Tx = round(rand(1,Num_Of_Bits));
%%%%%%%%%%%%%%%%%%%%%%%%%%%Coded Start%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
for num=1:Num_Of_Bits/k %transfer to matrix, each row has 7 data
Data_Tx_Matrix_k(num,:)=Binary_Data_Tx((num-1)*k+1:(num*k));
end
Data_Tx_Matrix_n=mod(Data_Tx_Matrix_k*G,2);% transfer to new matrix with 15 data each row with coding
Data_Tx_Coded=[];
for num=1:Num_Of_Bits/k %transfer to a row
Data_Input=Data_Tx_Matrix_n(num,:);
Data_Tx_Coded=[Data_Tx_Coded Data_Input];
end
Num_OfBits_Coded=Num_Of_Bits*n/k;
x_channel_Coded_data = Data_Tx_Coded(1:4:Num_OfBits_Coded); %x-component
y_channel_Coded_data = Data_Tx_Coded(2:4:Num_OfBits_Coded); %y-component
z_channel_Coded_data = Data_Tx_Coded(3:4:Num_OfBits_Coded); %z-component
w_channel_Coded_data = Data_Tx_Coded(4:4:Num_OfBits_Coded); %w-component
% I component of modulated signal
Data_Tx_I_channel_Coded = d*(((2.*y_channel_Coded_data) - 1).*(3.*(not(w_channel_Coded_data))+w_channel_Coded_data));
% Q component of modulated signal y
Data_Tx_Q_channel_Coded = d*((2.*x_channel_Coded_data - 1).*(3.*(not(z_channel_Coded_data))+z_channel_Coded_data));
% Addition of white noise
Data_Tx_Modulated_Coded = Data_Tx_I_channel_Coded + j*Data_Tx_Q_channel_Coded;
Noise_Coded = (n/k)*0.5*10^(-EbNo(Counter)/10); %Variance (Sigma squared) of Noise
Noise_Real_Coded=sqrt(Noise_Coded)*randn(1,(Num_OfBits_Coded/4)); %I
Noise_Imag_Coded=sqrt(Noise_Coded)*randn(1,(Num_OfBits_Coded/4)); %Q
combined_Noise_Coded=Noise_Real_Coded+j*Noise_Imag_Coded;
Signal_Rayleigh_Faded_Coded=[];
Number_Fading_Coeff=Num_OfBits_Coded/(4*Tc_by_Ts);
Rayleigh_Coded=sqrt(1/2)*randn(1,Number_Fading_Coeff)+j*sqrt(1/2)*randn(1,Number_Fading_Coeff);
for num=1:Num_OfBits_Coded/(4*Tc_by_Ts)
Faded_Signal=Rayleigh_Coded(num)*Data_Tx_Modulated_Coded(((num-1)*Tc_by_Ts)+1:(num*Tc_by_Ts));
Signal_Rayleigh_Faded_Coded=[Signal_Rayleigh_Faded_Coded Faded_Signal];
end
Data_Rx_Rayleigh_AWGN_Coded = Signal_Rayleigh_Faded_Coded+combined_Noise_Coded;
Data_Rx_Coded=[];
for q=1:Num_OfBits_Coded/(4*Tc_by_Ts)
Remainder_Rayleigh=Data_Rx_Rayleigh_AWGN_Coded((((q-1)*Tc_by_Ts)+1:(q*Tc_by_Ts)))/Rayleigh_Coded(q);
Data_Rx_Coded=[Data_Rx_Coded Remainder_Rayleigh];
end
%Demodulation & Error Detection
Data_Rx_Coded_I_component = real(Data_Rx_Coded); % I component
Data_Rx_Coded_Q_component = imag(Data_Rx_Coded); % Q component
Rx_x_channel_Coded_data= (sign(Data_Rx_Coded_Q_component) + 1)/2 ;
Rx_y_channel_Coded_data = (sign(Data_Rx_Coded_I_component) + 1)/2 ;
Rx_z_channel_Coded_data =(sign(abs(Data_Rx_Coded_Q_component) - 2*d) - 1)/(-2);
Rx_w_channel_Coded_data = (sign(abs(Data_Rx_Coded_I_component) - 2*d) - 1)/(-2);
Estimated_Data_in_Coded(1:4:Num_OfBits_Coded)=Rx_x_channel_Coded_data;
Estimated_Data_in_Coded(2:4:Num_OfBits_Coded)=Rx_y_channel_Coded_data;
Estimated_Data_in_Coded(3:4:Num_OfBits_Coded)=Rx_z_channel_Coded_data;
Estimated_Data_in_Coded(4:4:Num_OfBits_Coded)=Rx_w_channel_Coded_data;
for numm=1:Num_Of_Bits/k
r=Estimated_Data_in_Coded((numm-1)*n+1:numm*n);
rh_transpose=r*H';
rh_transpose=mod(rh_transpose,2);
for m=1:Error_Pattern_Number
if rh_transpose==Comparison_Table(m,16:23)
r=r+Comparison_Table(m,1:15);
r=mod(r,2);
rr=r(9:15);
else
rr=r(9:15); % if can't match S, which means bit error over 2
end
end
error=xor(rr,Data_Tx_Matrix_k(numm,:));
Number_of_Error_Coded=Number_of_Error_Coded+sum(error);
end
%%%%%%%%%%%%%%%%%%%%%%%%%Coded End%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%Uncoded start%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Seperating x y z & w component of data for 16 QAM Modulation