MANNE PAVAN KUMAR REDDY

EE14RESCH11005
DSP lab:MATLAB CODES AND OUTPUTS

1. BPSK_modulation
Code:
clc;close all;clear all;
%assuming Number of bits to be sent
N=10^6;
%data in 1s and 0s
data=rand(1,N)>0.5;
%modulating the data
bpsk=2*data-1;
%assuming snr
SNR=0:10;
for i=1:length(SNR)
%calculating sigma;
sigma=(10.^(-SNR(i)/20));%with asumption of Eb=1;
noise=sigma*randn(1,N);
%noise addition awgn
bpsk_rx=bpsk+noise;
h=randn(1,N)+1i*randn(1,N);
h=h/sqrt(2);
bpsk_rx_ch=bpsk.*h+noise;
%demodulation
for j=1:N
if bpsk_rx(j)>0
bpsk_est(j)=1;
else
bpsk_est(j)=-1;
end
end
bpsk_rx_ch=bpsk_rx_ch./h;
for j=1:N
if bpsk_rx_ch(j)>0
bpsk_est_ch(j)=1;
else
bpsk_est_ch(j)=-1;
end
end
%errors
errors=bpsk-bpsk_est;
errors_ch=bpsk-bpsk_est_ch;
ber(i)=length(find(abs(errors)))/length(data);
ber_ch(i)=length(find(abs(errors_ch)))/length(data);
i
end
SNR_L=10.^(SNR/10);

semilogy(SNR,qfunc(sqrt(SNR_L)),'b');
hold on
semilogy(SNR,ber,'r*');
legend('theoretical awgn','simulated bpsk w/o channel')
axis([1 10,10^-4 1]);
figure;
semilogy(SNR,ber_ch,'r*');
hold on;
semilogy(SNR,0.5*(1-sqrt(SNR_L./(SNR_L+1))),'b');
% axis([1 10,10^-3 10^-1]);
legend('theoretical awgn','simulated bpsk with channel')

Simulated for awgn channel and compared with theoretical equation Q(sqrt(SNR));

Simulated for flat fading channel and compared with Rayleigh equation for single
tap 0.5(1-sqrt(SNR/SNR+1))

2.QPSK Modulation flat fading and awgn:

clc;clear all;close all;
N=10^6;
data=rand(1,N)>0.5;
qpsk=QPSK_MOD(data);
for SNR=1:10
sigma= 10.^(-SNR/20);
noise=(randn(1,N/2)+1i*randn(1,N/2))/sqrt(2);
qpsk_rx(SNR,:)=sigma.*noise+qpsk;
h=1/sqrt(2).*(randn(1,N/2)+1i*randn(1,N/2)) ;
qpsk_rx_ch(SNR,:)=sigma.*noise+qpsk.*h;
% qpsk_rx_ch(SNR)=noise
qpsk_dmod_ch(SNR,:)=QPSK_DEMOD(qpsk_rx_ch(SNR,:)./h);
qpsk_dmod(SNR,:)=QPSK_DEMOD(qpsk_rx(SNR,:));
error(SNR,:)=qpsk_dmod(SNR,:)-data;
error_ch(SNR,:)=qpsk_dmod_ch(SNR,:)-data;
ber(SNR)=length(find(abs(error(SNR,:))))./length(data);
ber_ch(SNR)=length(find(abs(error_ch(SNR,:))))./length(data);
SNR
end
SNR=1:10;
SNR_L=10.^(SNR/10);
semilogy(qfunc(sqrt(SNR_L)),'b');
hold on;
semilogy(ber,'r*');
legend('theoretical qpsk','simulated w/o channel qpsk')
figure
semilogy(1/2*(1-sqrt(SNR_L./(SNR_L+2))),'b');
hold on;
semilogy(ber_ch,'r*');
legend('theoretical qpsk','simulated with channel qpsk')

Outputs:
Simulated graph for QPSK without channel awgn and theoretical comparision of
qpsk(sqrt(SNR));

Simulated graph for QPSK with channel flat fading and theoretical comparisision of
Rayleigh flat fading equation 0.5(1-sqrt(snr/snr+2))

3.OFDM (CP,flat fading and multipath)

a) without CP and flat fading
code:

clc;clear all;close all;

%length of data
N=10^5;
% no of carriers
N_car=512;
%data
data=rand(1,N)>0.5;
%modulation
qpsk_data=QPSK_MOD(data);
%zero padding
qpsk_data=[qpsk_data,zeros(1,N_car-mod(length(qpsk_data),N_car))];
for SNR=1:10
sigma=10^(-SNR/20);
serial_data=[];serial_data_n=[];
for i=1:ceil(length(qpsk_data)/N_car);
%serial to parallel conversion
parallel_data=[qpsk_data((i-1)*N_car+1:i*N_car)];
%channel consideration flat fading
H(i)=1/sqrt(2)*(randn(1,1)+1i*randn(1,1));
%noise
noise=1/sqrt(2)*(randn(1,N_car)+1i*randn(1,N_car));
%parallel to serial mux
serial_data=[serial_data ifft(parallel_data).*sqrt(N_car).*H(i)+
(noise.*sigma)];
serial_data_n=[serial_data_n ifft(parallel_data).*sqrt(N_car)+(noise.*sigma)];
end
% noise=1/sqrt(2)*(randn(1,length(serial_data))
+1i*rand(1,length(serial_data)));
data_tx=serial_data;
data_tx_n=serial_data_n;
%parallelisation
serial_tx=[];serial_tx_n=[];
for i=1:ceil(length(data_tx)/N_car);
parallel_rx=[data_tx((i-1)*N_car +1:i*N_car)];
parallel_rx_n=[data_tx_n((i-1)*N_car+1:i*N_car)];
%fft ==> ofdm demod
serial_tx=[serial_tx fft(parallel_rx./(sqrt(N_car).*H(i)))];
serial_tx_n=[serial_tx_n fft(parallel_rx_n./(sqrt(N_car)))];
end
% qpsk demodulation

qpsk_demod=QPSK_DEMOD(serial_tx);
qpsk_demod_n=QPSK_DEMOD(serial_tx_n);
errors=qpsk_demod(1:N)-data;
%errors
errors_n=qpsk_demod_n(1:N)-data;
ber(SNR)=length(find(abs(errors)))./length(data);
ber_n(SNR)=length(find(abs(errors_n)))./length(data);
SNR
end
SNR=1:10;
semilogy(ber,'r');
hold on;
SNR_L=10.^(SNR/10);
semilogy(0.5*(1-sqrt(SNR_L./(2+SNR_L))),'k*');
semilogy(qfunc(sqrt(SNR_L)),'g*');
semilogy(ber_n,'m');
legend('simulated ofdm qpsk Rayleigh','Theoretical ofdm qpsk
rayleigh','theoretical ofdm qpsk w/o channel','simulated ofdm qpsk w/o
channel');

b)with cp and multipath channel:

clc;clear all;close all;
%no of carriers data multi path taps
N=10^5;N_car=50;N_taps=10;
%data
data=rand(1,N)>0.5;
% data=ones(1,N);
%modulation
qpsk_data=QPSK_MOD(data);
qpsk_data=[qpsk_data,zeros(1,N_car-mod(length(qpsk_data),N_car))];
% sigma=0;
%preassigning zeros for interference of first symbol
serial_data=[];serial_data_n=zeros(1,N_car+N_taps1);serial_data_cp=zeros(1,N_car+N_taps-1);
for j=1:ceil(length(qpsk_data)/N_car);
%channel of N_taps
H_cp(j,:)=1/sqrt(2)*1/sqrt(N_taps)*(randn(1,N_taps)+1i*randn(1,N_taps));
% H_cp(j,:)=[1];
H=H_cp(j,:);
%paralle conversion
parallel_data=[qpsk_data((j-1)*N_car+1:j*N_car)];
parallel_ifft=ifft(parallel_data).*sqrt(N_car);
parallel_cp=[parallel_ifft(N_car-N_taps+2:N_car) parallel_ifft]; %channel
linear convolution
%ofdm modulation and channel convolution
ch_out=conv(ifft(parallel_data).*sqrt(N_car),H);
ch_out_cp=conv(parallel_cp,H);
%parallel to serial
serial_data_n=[serial_data_n(1:end-N_taps+1) serial_data_n(endN_taps+2:end)+ch_out(1:N_taps-1) ch_out(N_taps:end) ];
serial_data_cp=[serial_data_cp(1:end-N_taps+1) serial_data_cp(endN_taps+2:end)+ch_out_cp(1:N_taps-1) ch_out_cp(N_taps:end) ];
end
for SNR=1:10
%noise addition
data_tx_n=awgn(serial_data_n,SNR);
data_tx_cp=awgn(serial_data_cp,SNR);
%discard first N carrier zero padded bits
data_tx_n=data_tx_n(N_car+1:end);
data_tx_cp=data_tx_cp(N_car+1:end);
serial_tx_n=[];serial_tx_cp=[];
for i=1:ceil(length(qpsk_data)/N_car);

H=H_cp(i,:);
%parallel conversion
parallel_rx_n=[data_tx_n((i-1)*(N_car)+1:i*N_car)];
parallel_rx_cp=[data_tx_cp((i-1)*(N_car+N_taps-1)+1:i*(N_car+N_taps1))];
parallel_rx_cp=parallel_rx_cp(N_taps:end);
%channel equalising ofdm demodulation
parallel_out_n=fft(ifft(fft(parallel_rx_n)./fft(H,length(parallel_rx_n))))./
(sqrt(N_car));
serial_tx_n=[serial_tx_n parallel_out_n];
parallel_out_cp=fft(ifft(fft(parallel_rx_cp)./fft(H,length(parallel_rx_cp))))./
(sqrt(N_car));
serial_tx_cp=[serial_tx_cp parallel_out_cp];
end
%qpsk demodulation
qpsk_demod_cp=QPSK_DEMOD(serial_tx_cp);
qpsk_demod_n=QPSK_DEMOD(serial_tx_n);
%errors
errors_n=qpsk_demod_n(1:N)-data;
errors_cp=qpsk_demod_cp(1:N)-data;
ber_n(SNR)=length(find(abs(errors_n)))./length(data);
ber_cp(SNR)=length(find(abs(errors_cp)))./length(data);
SNR
end
SNR=1:10;
% semilogy(ber,'r*');
% hold on;
SNR_L=10.^(SNR/10);
semilogy(0.5*(1-sqrt(SNR_L./(2+SNR_L))),'k*');
hold on;
semilogy(ber_n,'m');
semilogy(ber_cp,'r')
legend('theoretical ofdm qpsk Rayleigh_flat fading','simulated ofdm qpsk
with multipathchannel ','simulated ofdm qpsk with multipath channel with
cp');

Outputs:
OFDM without cp and flat fading comparision:

Ofdm with cp and with Multi path channel:

4. Filtering an audio signal:

T=1000;
Fs=44100;
fc=Fs/2;
t=1/Fs:1/Fs:T;
X=cos(2*pi*fc*(1/Fs).*t);
figure;plot(t,X);
a=fir1(10,0.3,'high');%hera 0.6 is factor of fm/fs
b=fir1(10,0.6,'low');
Fs = 44100;%samples/sec
%reading audio file
samples = [1,9*Fs];
[x,Fs]=wavread('amy.wav',samples);
x1=x(:,1);%here speech is two dimentional vector to take only one dimention
data
y1=conv(x1,a);
wavwrite(y1,Fs,'hpf.wav');
y2=conv(x1,b);
wavwrite(y2,Fs,'lpf.wav');
Y=y1+y2;
wavwrite(Y,Fs,'cmplt.wav');

OTHER FUNCTIONS USED FOR THE SIMULATIONS

QPSK_MODULATION:
function out=QPSK_MOD(data);
for i=1:length(data)/2
if data(2*i-1)==1
if data(2*i)==1
out(i)=1+1i;
else out(i)=1-1i;
end
else
if data (2*i)==1
out(i)=-1+1i;
else
out(i)=-1-1i;
end
end
end
out=out./sqrt(2);

QPSK DEMODULATION:
function out=QPSK_DEMOD(data)
for i=1:length(data)
if real(data(i))>0
if imag(data(i))>0
out(2*i-1:2*i)=[1 1];
else
out(2*i-1:2*i)=[1 0];
end
else
if imag(data(i))<0
out(2*i-1:2*i)=[0 0];
else
out(2*i-1:2*i)=[0 1];
end
end
end
end