Professional Documents
Culture Documents
START
ENTER THE SIGNAL
PARAMETERS (AMPLITUDE,
TIME AND FREQUENCY)
STOP
UR11EC098
EX. NO :1
DATE:09-12-13
WAVEFORM GENERATION
AIM:
Write a program in MATLAB to generate the following waveforms
(Discrete Time signal and Continuous Time signal)
1. Unit Impulse sequence,
1. Pulse signal,
3. Ramp signal
4. Sinusoidal sequence,
4. Sinusoidal signal,
5. Exponential sequence,
5. Exponential signal,
6. Random sequence,
6. Random
signal
APPARATUS REQUIRED:
Pentium 4 Processor, MATLAB software
THEORY:
Real signals can be quite complicated. The study of signals therefore
starts with the analysis of basic and fundamental signals. For linear systems,
a complicated signal and its behaviour can be studied by superposition of
basic signals. Common basic signals are:
Discrete Time signals:
1, for n 0
0, otherwise
1, for n 0
0, otherwise
n, for n 0
0, otherwise
UR11EC098
1, for t 0
x (t ) u(t )
0, otherwise
Unit step signal.
t , for t 0
x (t ) r (t )
0, otherwise
UR11EC098
R = INPUT('How many apples') gives the user the prompt in the text
string and then waits for input from the keyboard. The input can be
any MATLAB expression, which is evaluated,using the variables in
the current workspace, and the result returned in R. If the user presses
the return key without entering anything, INPUT returns an empty
matrix.
linspace:
LINSPACE Linearly spaced vector.
LINSPACE(X1, X2) generates a row vector of 100 linearly equally
spaced points between X1 and X2.
rand:
The rand function generates arrays of random numbers whose
elements are uniformly distributed in the interval (0,1).
ones:
ONES(N) is an N-by-N matrix of ones.
ONES(M,N) or ONES([M,N]) is an M-by-N matrix of ones.
zeros:
ZEROS(N) is an N-by-N matrix of Zeros.
ZEROS(M,N) or ZEROS([M,N]) is an M-by-N matrix of zeros
plot:
PLOT Linear plot.
PLOT(X,Y) plots vector Y versus vector X. If X or Y is a matrix, then
the vector is plotted versus the rows or columns of the matrix,
whichever line up.
subplot:
SUBPLOT Create axes in tiled positions.
H = SUBPLOT(m,n,p), or SUBPLOT(mnp), breaks the Figure
window into an m-by-n matrix of small axes, selects the p-th axes for
the current plot, and returns the axis handle. The axes are counted
along the top row of the Figure window, then the second row, etc.
UR11EC098
stem:
STEM Discrete sequence or "stem" plot.
STEM(Y) plots the data sequence Y as stems from the x axis
terminated with circles for the data value.
STEM(X,Y) plots the data sequence Y at the values specified in X.
title:
TITLE Graph title.
TITLE('text') adds text at the top of the current axis.
xlabel:
XLABEL X-axis label.
XLABEL('text') adds text beside the X-axis on the current axis.
ylabel:
YLABEL Y-axis label.
YLABEL('text') adds text beside the Y-axis on the current axis.
ALGORITHM/PROCEDURE:
1. Start the program
2. Get the inputs for signal generation
3. Use the appropriate library function
4. Display the waveform
Source code :
%WAVE FORM GENERATION
%CT SIGNAL
%UNIT IMPULSE
clc;
clear all;
close all;
t1=-3:1:3;
x1=[0,0,0,1,0,0,0];
subplot(2,3,1);
plot(t1,x1);
xlabel('time');
5
UR11EC098
ylabel('Amplitude');
title('Unit impulse signal');
%UNIT STEP SIGNAL
t2=-5:1:25;
x2=[zeros(1,5),ones(1,26)];
subplot(2,3,2);
plot(t2,x2);
xlabel('time');
ylabel('Amplitude');
title('Unit step signal');
%EXPONENTIAL SIGNAL
a=input('Enter the value of a:');
t3=-10:1:20;
x3=exp(-1*a*t3);
subplot(2,3,3);
plot(t3,x3);
xlabel('time');
ylabel('Amplitude');
title('Exponential signal');
%UNIT RAMP SIGNAL
t4=-10:1:20;
x4=t4;
subplot(2,3,4);
plot(t4,x4);
xlabel('time');
ylabel('Amplitude');
title('Unit ramp signal');
%SINUSOIDAL SIGNAL
A=input('Enter the amplitude:');
f=input('Enter the frequency:');
t5=-10:1:20;
x5=A*sin(2*pi*f*t5);
subplot(2,3,5);
plot(t5,x5)
xlabel('time');
ylabel('Amplitude');
title('Sinusoidal signal');
%RANDOM SIGNAL
t6=-10:1:20;
x6=rand(1,31);
6
UR11EC098
subplot(2,3,6);
plot(t6,x6);
xlabel('time');
ylabel('Amplitude');
title('Random signal');
%WAVE FORM GENERATION
%DT SIGNAL
%UNIT IMPULSE
clc;
clear all;
close all;
n1=-3:1:3;
x1=[0,0,0,1,0,0,0];
subplot(2,3,1);
stem(n1,x1);
xlabel('time');
ylabel('Amplitude');
title('Unit impulse signal');
%UNIT STEP SIGNAL
n2=-5:1:25;
x2=[zeros(1,5),ones(1,26)];
subplot(2,3,2);
stem(n2,x2);
xlabel('time');
ylabel('Amplitude');
title('Unit step signal');
%EXPONENTIAL SIGNAL
a=input('Enter the value of a:');
n3=-10:1:20;
x3=power(a,n3);
subplot(2,3,3);
stem(n3,x3);
xlabel('time');
ylabel('Amplitude');
title('Exponential signal');
%UNIT RAMP SIGNAL
n4=-10:1:20;
x4=n4;
subplot(2,3,4);
7
UR11EC098
stem(n4,x4);
xlabel('time');
ylabel('Amplitude');
title('Unit ramp signal');
%SINUSOIDAL SIGNAL
A=input('Enter the amplitude:');
f=input('Enter the frequency:');
n5=-10:1:20;
x5=A*sin(2*pi*f*n5);
subplot(2,3,5);
stem(n5,x5);
xlabel('time');
ylabel('Amplitude');
title('Sinusoidal signal');
%RANDOM SIGNAL
n6=-10:1:20;
x6=rand(1,31);
subplot(2,3,6);
stem(n6,x6);
xlabel('time');
ylabel('Amplitude');
title('Random signal');
CONTINUOUS TIME:
UR11EC098
DISCRETE TIME :
UR11EC098
RESULT:
The program to generate various waveforms is written, executed
and the output is verified.
10
UR11EC098
FLOWCHART:
START
STOP
11
UR11EC098
EX. NO :2
DATE :21-12-13
AIM:
at each
corresponding sample.
2. Time manipulation
Time scaling:
Time shifting:
UR11EC098
Arithmetic Operations
*
Matrix multiplication
.*
LIBRARY FUNCTIONS:
date Current date as date string.
S = date returns a string containing the date in dd-mmm-yyyy format
Fprintf
Write formatted data to file. The special formats \n,\r,\t,\b,\f can be
used to produce linefeed, carriage return, tab, backspace, and
formfeed characters respectively.
Use \\ to produce a backslash character and %% to produce the
percent character.
ALGORITHM/PROCEDURE:
1. Start the program
2. Get the input for signal manipulation
3. Use the appropriate library function
4. Display the waveform
13
UR11EC098
Source code :
clc;
clear all;
close all;
%operations on the amplitude of signal
x=input('Enter input sequence:');
a=input('Enter amplification factor:');
b=input('Enter attenuation factor:');
c=input('Enter amplitude reversal factor:');
y1=a*x;
y2=b*x;
y3=c*x;
n=length(x);
subplot(2,2,1);
stem(0:n-1,x);
xlabel('time');
ylabel('amplitude');
title('Input signal');
subplot(2,2,2);
stem(0:n-1,y1);
xlabel('time');
ylabel('Amplitude');
title('Amplified signal');
subplot(2,2,3);
stem(0:n-1,y2);
xlabel('time');
ylabel('Amplitude');
title('Attenuated signal');
subplot(2,2,4);
stem(0:n-1,y3);
xlabel('time');
ylabel('Amplitude');
title('Amplitude reversal signal');
%scalar addition
d=input('Input the scalar to be added:');
y4=d+x;
figure(2);
stem(0:n-1,y4);
xlabel('time');
14
UR11EC098
ylabel('Amplitude');
title('Scalar addition signal');
clc;
clear all;
close all;
%Operations on the independent variable
%Time shifting of the independent variable
x=input('Enter the input sequence:');
n0=input('Enter the +ve shift:');
n1=input('Enter the -ve shift:');
l=length(x);
subplot(2,2,1);
stem(0:l-1,x);
xlabel('time');
ylabel('Amplitude');
title('Input signal');
i=n0:l+n0-1;
j=n1:l+n1-1;
subplot(2,2,2);
stem(i,x);
xlabel('time');
ylabel('Amplitude');
title('Positive shifted signal');
subplot(2,2,3);
stem(j,x);
xlabel('time');
ylabel('Amnplitude');
title('Negative shifted signal');
%Time reversal
subplot(2,2,4);
stem(-1*(0:l-1),x);
xlabel('time');
ylabel('Amplitude');
title('Time reversal signal');
15
UR11EC098
clc;
clear all;
close all;
%Arithmetic operations on signals
%Addition and multiplication of two signals
x1=input('Enter the sequence of first signal:');
x2=input('Enter the sequence of second signal:');
l1=length(x1);
l2=length(x2);
subplot(2,2,1);
stem(0:l1-1,x1);
xlabel('time');
ylabel('Amplitude');
title('Input sequence 1');
subplot(2,2,2);
stem(0:l2-1,x2);
xlabel('time');
ylabel('Amplitude');
title('Input sequence 2');
if l1>l2
l3=l1-l2;
x2=[x2,zeros(1,l3)];
y1=x1+x2;
subplot(2,2,3);
stem(0:l1-1,y1);
xlabel('time');
ylabel('Amplitude');
title('Addition of two signals');
y2=x1.*x2;
subplot(2,2,4);
stem(0:l1-1,y2);
xlabel('time');
ylabel('Amplitude');
title('Multiplication of two signals');
end
if l2>l1
l3=l2-l1;
x1=[x1,zeros(1,l3)];
y1=x1+x2;
subplot(2,2,3);
16
UR11EC098
stem(0:l2-1,y1);
xlabel('time');
ylabel('Amplitude');
title('Addition of two signals');
y2=x1.*x2;
subplot(2,2,4);
stem(0:l2-1,y2);
xlabel('time');
ylabel('Amplitude');
title('Multiplication of two signals');
else
y1=x1+x2;
subplot(2,2,3);
stem(0:l1-1,y1);
xlabel('time');
ylabel('Amplitude');
title('Addition of two signals');
y2=x1.*x2;
subplot(2,2,4);
stem(0:l1-1,y2);
xlabel('time');
ylabel('Amplitude');
title('Multiplication of two signals');
end
operations on the amplitude of signal :
17
UR11EC098
18
UR11EC098
19
UR11EC098
RESULT:
UR11EC098
FLOWCHART:
START
STOP
21
UR11EC098
EX. NO : 3
DATE: 06-1-14
AIM:
To check for linearity, Causality and stability of various systems
given bellow:
Linearity:
System1
n.X(n),
System2
An.X2(n)+B
System3:
Log
(X),sin(x),5X(n) etc
Causality: System1 U(-n) System2 X(n-4)+U(n+5)
Stability: System1 Z / (Z2 + 0.5 Z+1)
APPARATUS REQUIRED:
Pentium 4 Processor, MATLAB software
THEORY:
LINEARITY:
The response of the system to a weighted sum of signals is equal to
the corresponding weighted sum of the responses (outputs) of the system to
each of the individual input signals.
T [ a 1 x 1 ( n ) a 2 x 2 ( n )] a 1T [ x 1 ( n )] a 2 T [ x 2 ( n )]
METHODS OF PROOF:
Individual inputs are applied and the weighted sum of the outputs is
taken. Then the weighted sum of signals input is applied to the system and
the two outputs are checked to see if they are equal.
CAUSALITY:
A system is said to be causal, if the output of the system at any time
n(y(n)) depends only on the present and past inputs and past outputs
[x(n),x(n-1).y(n-1),..]
22
UR11EC098
STABILITY:
An arbitrary relaxed system is said to be bounded input bounded
output (BIBO) stable, if and only if every bounded input produces a bounded
output.
METHODS OF PROOF:
1. If the impulse response is given, then the summation of responses for
n ranging from
23
UR11EC098
LIBRARY FUNCTION:
.^ Array power.
Z = X.^Y denotes element-by-element powers. X and Y must have
the same dimensions unless one is a scalar. A scalar can operate into
anything.
24
UR11EC098
ALGORITHM/PROCEDURE:
1. Click on the MATLAB icon on the desktop (or go to start all
programs and click
on MATLAB) to get into the Command Window
2. Type edit in the MATLAB prompt >> that appears in the
Command window.
3. Write the program in the Edit window and save it in M-file
4. Run the program
5. Enter the input in the command window
6. The result is displayed in the Command window and the graphical
output is displayed in the Figure Window
Source code :1
clc;
clear all;
close all;
%Properties of DT Systems(Linearity)
%y(n)=[x(n)]^2+B;
x1=input('Enter first input sequence:');
n=length(x1);
x2=input('Enter second input sequence:');
a=input('Enter scaling constant(a):');
b=input('Enter scaling constant(b):');
B=input('Enter scaling constant(B):');
y1=power(x1,2)+B;
y2=power(x2,2)+B;
rhs=a*y1+b*y2;
x3=a*x1+b*x2;
lhs=power(x3,2)+B;
25
UR11EC098
subplot(2,2,1);
stem(0:n-1,x1);
xlabel('Time');
ylabel('Amplitude');
title('First input sequence');
subplot(2,2,2);
stem(0:n-1,x2);
xlabel('Time');
ylabel('Amplitude');
title('Second input sequence');
subplot(2,2,3);
stem(0:n-1,lhs);
xlabel('Time');
ylabel('Amplitude');
title('LHS');
subplot(2,2,4);
stem(0:n-1,rhs);
xlabel('Time');
ylabel('Amplitude');
title('RHS');
if(lhs==rhs)
display('system is linear');
else
display('system is non-linear');
end;
Source code :2
clc;
clear all;
close all;
%Properties of DT Systems(Linearity)
%y(n)=x(n);
x1=input('Enter first input sequence:');
x2=input('Enter second input sequence:');
a=input('Enter scaling constant(a):');
b=input('Enter scaling constant(b):');
26
UR11EC098
subplot(2,2,1);
stem(x1);
xlabel('time');
ylabel('Amplitude');
title('First signal');
subplot(2,2,2);
stem(x2);
xlabel('time');
ylabel('Amplitude');
title('Second signal');
y1=x1;
y2=x2;
rhs=a*y1+b*y2;
x3=a*x1+b*x2;
lhs=x3;
if(lhs==rhs)
display('system is linear');
else
display('system is non-linear');
end;
subplot(2,2,3);
stem(lhs);
xlabel('time');
ylabel('Amplitude');
title('L.H.S');
subplot(2,2,4);
stem(rhs);
xlabel('time');
ylabel('Amplitude');
title('R.H.S');
Source code :3
clc;
clear all;
close all;
%Properties of DT Systems(Time Invariance)
%y(n)=x(n);
27
UR11EC098
UR11EC098
UR11EC098
Source code :5
clc;
clear all;
close all;
%Properties of DT Systems(Causality)
%y(n)=x(-n);
x1=input('Enter input sequence x1:');
n1=input('Enter lower limit n1:');
n2=input('Enter lower limit n2:');
flag=0;
for n=n1:n2
arg=-n;
if arg>n;
flag=1;
end;
end;
if(flag==1)
display('system is causal');
else
display('system is non-causal');
end;
Source code :6
disp('stability');
nr=input('input the numerator coefficients:');
dr=input('input the denominator coefficients:');
z=tf(nr,dr,1);
[r,p,k]=residuez(nr,dr);
figure
zplane(nr,dr);
if abs(p)<1
disp('the system is stable');
else
disp('the system is unstable');
end;
30
UR11EC098
Non-Linear System :1
Output :
31
UR11EC098
Linear System :2
Output :
32
UR11EC098
Output :
33
UR11EC098
Output :
34
UR11EC098
Non-Causal system :5
Unstable system :6
Output :
35
UR11EC098
RESULT:
The properties of Discrete Time system is verified using MATLAB
36
UR11EC098
FLOWCHART:
START
STOP
37
UR11EC098
EX. NO : 4
DATE: 13-1-14
AIM:
THEORY:
SAMPLING PROCESS:
It is a process by which a continuous time signal is converted into
discrete time signal. X[n] is the discrete time signal obtained by taking
samples of the analog signal x(t) every T seconds, where T is the sampling
period.
X[n] = x (t) x p (t)
Where p(t) is impulse train;
SAMPLING THEOREM:
It states that the band limited signal x(t) having no frequency
components above Fmax Hz is specified by the samples that are taken at a
uniform rate greater than 2 Fmax Hz (Nyquist rate), or the frequency equal to
twice the highest frequency of x(t).
Fs 2 Fmax
SAMPLING RATE CONVERSION:
Sampling rate conversion is employed to generate a new sequence
with a sampling rate higher or lower than that of a given sequence. If x[n] is
38
UR11EC098
ANTIALIASING
FILTER H (Z)
y[n]
n = 0, 1, 2 .
otherwise
39
UR11EC098
The sampling rate of y[n] is L times that of x[n]. The unwanted images in
the spectra of sampled signal must be removed by a LPF called anti-imaging
filter. The input sequence is passed through an anti-imaging filter after up
sampling.
x[n]
ANTI IMAGING
FILTER H (Z)
y[n]
ANTI
IMAGING
FILTER
ANTI
ALIASING
FILTER
DOWN
SAMPLER
y[n]
LIBRARY FUNCTIONS:
resample: Changes sampling rate by any rational factor.
y = resample (x,p,q) resamples the sequence in vector x at p/q times the
original sampling rate, using a polyphase filter implementation. p and q must
be positive integers. The length of y is equal to ceil (length(x)*p/q).
interp:
(interpolation)
y = interp (x,r) increases the sampling rate of x by a factor of r. The
interpolated vector y is r times longer than the original input x. interp
performs low pass interpolation by inserting zeros into the original sequence
and then applying a special low pass filter.
40
UR11EC098
ALGORITHM/PROCEDURE:
1. Generate a sinusoidal waveform
2. Using the appropriate library function for interpolation ,decimation
,upsampling ,
downsampling and resampling, perform sampling rate conversion for
the sinusoidal waveform
3. Find the spectrum of all the signals and compare them in frequency
domain.
4. Display the resultant waveforms
41
UR11EC098
Source code :
clc;
clear all;
close all;
%continuous sinusoidal signal
a=input('Enter the amplitude:');
f=input('Enter the Timeperiod:');
t=-10:1:20;
x=a*sin(2*pi*f*t);
subplot(2,3,1);
plot(t,x);
xlabel('time');
ylabel('Amplitude');
title('Sinusoidal signal');
%decimating the signal
d=input('Enter the value by which the signal is to be decimated:');
y1=decimate(x,d);
subplot(2,3,2);
stem(y1);
xlabel('time');
ylabel('Amplitude');
title('Decimated signal');
%interpolating the signal
i=input('Enter the value by which the signal is to be interpolated:');
y2=interp(x,i);
subplot(2,3,3);
stem(y2);
xlabel('time');
ylabel('Amplitude');
title('Interpolated signal');
%resampling the signal
y3=resample(x,3,2);
subplot(2,3,4);
stem(y3);
xlabel('time');
ylabel('Amplitude');
title('Resampled signal');
%downsampling the signal
42
UR11EC098
y4=downsample(x,2);
subplot(2,3,5);
stem(y4);
xlabel('time');
ylabel('Amplitude');
title('Downsampled signal');
%upsampling the signal
y5=upsample(x,3);
subplot(2,3,6);
stem(y5);
xlabel('time');
ylabel('Amplitude');
title('Upsampled signal');
43
UR11EC098
Output :
44
UR11EC098
RESULT:
The program written using library functions and the sampling rate
conversion process is studied.
45
UR11EC098
FLOWCHART:
START
STOP
46
UR11EC098
EX. NO : 5
DATE : 20-1-14
DISCRETE CONVOLUTION
AIM:
Write a MATLAB Script to perform discrete convolution (Linear and
Circular) for the given two sequences and also prove by manual calculation.
APPARATUS REQUIRED:
PC, MATLAB software
THEORY:
LINEAR CONVOLUTION:
The response y[n] of a LTI system for any arbitrary input x[n] is given
by convolution of impulse response h[n] of the system and the arbitrary
input x[n].
y[n] = x[n]*h[n] =
x[k ]h[n k ]
or
h[k ]x[n k ]
If the input x[n] has N1 samples and impulse response h[n] has N2
samples then the output sequence y[n] will be a finite duration sequence
consisting of (N1 + N2 - 1) samples. The convolution results in a non
periodic sequence called Aperiodic convolution.
UR11EC098
CIRCULAR CONVOLUTION
The convolution of two periodic sequences with period N is called
circular convolution of two signals x1[n] and x2[n] denoted by
N 1
N 1
x (k )
k 0
x2 [(n-k)
mod N]
where x1[(n-k) mod N] is the reflected and circularly translated version of
x1[n].
x1[n] * x2[n] = IDFTN { DFTN (x1[n] ) . DFTN (x2[n])}
It can be performed only if both the sequences consist of equal
number of samples. If the sequences are different in length then convert the
smaller size sequence to that of larger size by appending zeros
METHODS FOR CIRCULAR CONVOLUTION:
Matrix Multiplication Method and Concentric Circle Method
LIBRARY FUNCTION:
conv: Convolution and polynomial multiplication.
48
UR11EC098
ALGORITHM/PROCEDURE:
LINEAR CONVOLUTION:
1. Enter the sequences (Input x[n] and the Impulse response h[n])
2. Perform the linear convolution between x[k] and h[k] and obtain y[n].
3. Find the FFT of x[n] & h[n].Obtain X and H
4. Multiply X and H to obtain Y
5. Find the IFFT of Y to obtain y[n]
6. Compute error in time domain e=y[n]-y[n]
7. Plot the Results
49
UR11EC098
CIRCULAR CONVOLUTION
1. Enter the sequences (input x[n] and the impulse response h[n])
2. Make the length of the sequences equal by padding zeros to the
smaller length sequence.
3. Perform the circular convolution between x[k] and h[k]and obtain
y[n].
4. Find the FFT of x[n] & h[n].Obtain X and H
5. Multiply X and H to obtain Y
6. Find the IFFT of Y to obtain y[n]
7. Compute error in time domain e=y[n]-y[n]
8. Plot the Results
SOURCE CODE : 1
clc;
clear all;
close all;
%Program to perform Linear Convolution
x1=input('Enter the first sequence to be convoluted:');
subplot(3,1,1);
stem(x1);
xlabel('Time');
ylabel('Amplitude');
title('First sequence');
x2=input('Enter the second sequence to be convoluted:');
subplot(3,1,2);
stem(x2);
xlabel('Time');
ylabel('Amplitude');
title('Second sequence');
f=conv(x1,x2);
50
UR11EC098
OUTPUT :
51
UR11EC098
SOURCE CODE :2
clc;
clear all;
close all;
%Program to perform Circular Convolution
x1=input('Enter the first sequence to be convoluted:');
subplot(3,1,1);
l1=length(x1);
stem(x1);
xlabel('Time');
ylabel('Amplitude');
title('First sequence');
x2=input('Enter the second sequence to be convoluted:');
subplot(3,1,2);
l2=length(x2);
stem(x2);
xlabel('Time');
ylabel('Amplitude');
title('Second sequence');
if l1>l2
l3=l1-l2;
x2=[x2,zeros(1,l3)];
elseif l2>l1
l3=l2-l1;
x1=[x1,zeros(1,l3)];
end
f=cconv(x1,x2);
disp('The Circular convoluted sequence is');
disp(f);
subplot(3,1,3);
stem(f);
xlabel('Time');
ylabel('Amplitude');
title('Circular Convoluted sequence');
52
UR11EC098
Command window :
OUTPUT :
53
UR11EC098
SOURCE CODE :3
clc;
clear all;
close all;
%Program to perform Linear Convolution using Circular Convolution
x1=input('Enter the first sequence to be convoluted:');
subplot(3,1,1);
l1=length(x1);
stem(x1);
xlabel('Time');
ylabel('Amplitude');
title('First sequence');
x2=input('Enter the second sequence to be convoluted:');
subplot(3,1,2);
l2=length(x2);
stem(x2);
xlabel('Time');
ylabel('Amplitude');
title('Second sequence');
if l1>l2
l3=l1-l2;
x2=[x2,zeros(1,l3)];
elseif l2>l1
l3=l2-l1;
x1=[x1,zeros(1,l3)];
end
n=l1+l2-1;
f=cconv(x1,x2,n);
disp('The convoluted sequence is');
disp(f);
subplot(3,1,3);
stem(f);
xlabel('Time');
ylabel('Amplitude');
title('Convoluted sequence');
54
UR11EC098
Command window :
OUTPUT:
55
UR11EC098
SOURCE CODE :4
clc;
clear all;
close all;
%Program to perform Linear Convolution
x=input('Enter the first input sequence:');
l1=length(x);
subplot(3,2,1);
stem(x);
xlabel('Time index n---->');
ylabel('Amplitude');
title('input sequence');
h=input('Enter the system response sequence:');
l2=length(h);
subplot(3,2,2);
stem(h);
xlabel('Time index n---->');
ylabel('Amplitude');
title('system response sequence');
if l1>l2
l3=l1-l2;
h=[h,zeros(1,l3)];
elseif l2>l1
l3=l2-l1;
x=[x,zeros(1,l3)];
end
y=conv(x,h);
disp('The time domain convoluted sequence is:');
disp(y);
subplot(3,2,3);
stem(y);
xlabel('Time index n---->');
ylabel('Amplitude');
title('convoluted output sequence');
56
UR11EC098
X=fft(x,length(y));
H=fft(h,length(y));
Y=X.*H;
disp('The frequency domain multiplied sequence is:');
disp(Y);
subplot(3,2,4);
stem(Y);
xlabel('Time index n---->');
ylabel('Amplitude');
title('frequency domain multiplied response');
y1=ifft(Y,length(Y));
disp('The inverse fourier transformed sequence is:');
disp(y1);
subplot(3,2,5);
stem(y1);
xlabel('Time index n---->');
ylabel('Amplitude');
title('output after inverse fourier transform');
e=y-y1;
disp('The Error sequence:')
disp(abs(e));
subplot(3,2,6);
stem(abs(e));
xlabel('Time index n---->');
ylabel('Amplitude');
title('error sequence');
57
UR11EC098
Command window :
OUTPUT :
58
UR11EC098
SOURCE CODE :5
clc;
clear all;
close all;
%PROGRAM FOR CIRCULAR CONVOLUTION USING DISCRETE
CONVOLUTION EXPRESSION
x=input('Enter the first sequence:');
n1=length(x);
h=input('Enter the second sequence:');
n2=length(h);
n=0:1:n1-1;
subplot(3,1,1);
stem(n,x);
xlabel('Time');
ylabel('Amplitude');
title('First sequence Response x(n)');
n=0:1:n2-1;
subplot(3,1,2);
stem(n,h);
xlabel('Time');
ylabel('Amplitude');
title('Second sequence Response h(n)');
n=n1+n2-1;
if n1>n2
n3=n1-n2;
h=[h,zeros(1,n3)];
elseif n2>n1
n3=n2-n1;
x=[x,zeros(1,n3)];
end
x=[x,zeros(1,n-n1)];
h=[h,zeros(1,n-n2)];
for n=1:n
y(n)=0;
for i=1:n
j=n-i+1;
if(j<=0)
j=n+j;
59
UR11EC098
end
y(n)=y(n)+x(i)*h(j);
end
end
disp('Circular Convolution of x&h is');
disp(y);
subplot(3,1,3);
stem(y);
xlabel('Time');
ylabel('Amplitude');
title('Circular Convoluted sequence Response');
Command window :
OUTPUT :
60
UR11EC098
RESULT:
The linear and circular convolutions are performed by using
MATLAB script and the program results are verified by manual calculation.
61
UR11EC098
FLOWCHART:
START
STOP
62
UR11EC098
EX. NO : 6
DATE : 27-1-14
AIM:
Write a MATLAB program to perform the Discrete Fourier
Transform for the given sequences.
.
APPARATUS REQUIRED:
PC, MATLAB software
THEORY:
DISCRETE FOURIER TRANSFORM
Fourier analysis is extremely useful for data analysis, as it breaks
down a signal into constituent sinusoids of different frequencies. For
sampled vector data Fourier analysis is performed using the Discrete Fourier
Transform (DFT).
The Discrete Fourier transform computes the values of the Ztransform for evenly spaced points around the circle for a given sequence.
If the sequence to be represented is of finite duration i.e. it has only a
finite number of non-zero values, the transform used is Discrete Fourier
transform.
It finds its application in Digital Signal processing including Linear
filtering, Correlation analysis and Spectrum analysis.
63
UR11EC098
1 N 1
j2 n k N
x(n) e
, for k 0 ... N 1
N n0
LIBRARY FUNCTIONS:
exp: Exponential Function.
exp (X) is the exponential of the elements of X, e to the power X. For
complex Z=X+i*Y, exp (Z) = exp(X)*(COS(Y) +i*SIN(Y)).
disp: Display array.
disp (X) is called for the object X when the semicolon is not used to
terminate a statement.
64
UR11EC098
ALGORITHM/PROCEDURE:
1. Click on the MATLAB icon on the desktop (or go to Start - All
Programs and click on MATLAB) to get into the Command Window
2. Type edit in the MATLAB prompt >> that appears in the
Command window.
3. Write the program in the Edit window and save it as m-file
4. Run the program
5. Enter the input in the command window
6. The result is displayed in the Command window and the graphical
output is displayed in the Figure Window
Source Code :
clc;
clear all;
close all;
%Get the sequence from user
disp('The sequence from the user:');
xn=input('Enter the input sequence x(n):');
% To find the length of the sequence
65
UR11EC098
N=length(xn);
%To initilise an array of same size as that of input sequence
Xk=zeros(1,N);
iXk=zeros(1,N);
%code block to find the DFT of the sequence
for k=0:N-1
for n=0:N-1
Xk(k+1)=Xk(k+1)+(xn(n+1)*exp((-i)*2*pi*k*n/N));
end
end
%code block to plot the input sequence
t=0:N-1;
subplot(3,2,1);
stem(t,xn);
ylabel ('Amplitude');
xlabel ('Time Index');
title ('Input Sequence');
%code block to plot the X(k)
disp('The discrete fourier transform of x(n):');
disp(Xk);
t=0:N-1;
subplot(3,2,2);
stem(t,Xk);
ylabel ('Amplitude');
xlabel ('Time Index');
title ('X(k)');
UR11EC098
stem(t,magnitude);
ylabel ('Amplitude');
xlabel ('K');
title ('Magnitude Response');
%To find the phases of individual DFT points
phase=angle(Xk);
%code block to plot the phase response
disp('The phase response of X(k):');
disp(phase);
t=0:N-1;
subplot(3,2,4);
stem(t,phase);
ylabel ('Phase');
xlabel ('K');
title ('Phase Response');
% Code block to find the IDFT of the sequence
for n=0:N-1
for k=0:N-1
iXk(n+1)=iXk(n+1)+(Xk(k+1)*exp(i*2*pi*k*n/N));
end
end
iXk=iXk./N;
%code block to plot the output sequence
t=0:N-1;
subplot(3,2,5);
stem(t,xn);
ylabel ('Amplitude');
xlabel ('Time Index');
title ('IDFT sequence');
%code block to plot the FFT of input sequence using inbuilt function
x2=fft(xn);
subplot(3,2,6);
stem(t,x2);
67
UR11EC098
ylabel ('Amplitude');
xlabel ('Time Index');
title ('FFT of input sequence');
Command Window :
OUTPUT :
68
UR11EC098
RESULT:
The program for DFT calculation was performed with library
functions and without library functions. The results were verified by manual
calculation.
69
UR11EC098
FLOWCHART:
START
STOP
70
UR11EC098
EX. NO :7
DATE :3-2-14
AIM:
Write a MATLAB Script to compute Discrete Fourier Transform and
Inverse Discrete Fourier Transform of the given sequence using FFT
algorithms (DIT-FFT & DIF-FFT)
.
APPARATUS REQUIRED:
PC, MATLAB software
THEORY:
DFT is a powerful tool for performing frequency analysis of discrete
time signal and it is described as a frequency domain representation of a DT
sequence.
The DFT of a finite duration sequence x[n] is given by
N 1
X (k) =
x(n)e
j 2 nk/N
k=0, 1.N-1
n0
X (k) =
n0
nk
x(n)w N
k=0, 1.N-1
COMPUTATION OF DFT:
To compute DFT, it requires N2 multiplication and (N-1) N complex
addition. Direct computation of DFT is basically inefficient precisely
71
UR11EC098
because it does not exploit the symmetry and periodicity properties of phase
factor WN.
FAST FOURIER TRANSFORM (FFT):
FFT is a method of having computationally efficient algorithms for
the execution of DFT, under the approach of Divide and Conquer. The
number of computations can be reduced in N point DFT for complex
multiplications to N/2log2N and for complex addition to N/2log2N.
Types of FFT are,
(i) Decimation In Time (DIT)
(ii)Decimation In Frequency (DIF)
IDFT USING FFT ALGORITHMS:
The inverse DFT of an N point sequence X (k), where
k=0,1,2N-1 is defined as ,
1 N 1
nk
x [n] = X (k )W N
N n0
where, wN=e-j2/N.
Taking conjugate and multiplying by N, we get,
N 1
N x*[n] =
k 0
X * ( k )W Nnk
The right hand side of the equation is the DFT of the sequence X*(k).
Now x[n] can be found by taking the complex conjugate of the DFT and
dividing by N to give,
1 N 1 *
x [n]= [ X (k ) W Nnk ]*
N k 0
72
UR11EC098
LIBRARY FUNCTION:
fft: Discrete Fourier transform.
fft(x) is the discrete Fourier transform (DFT) of vector x. For matrices,
the FFT operation is applied to each column. For N-Dimensional arrays,
the FFT operation operates on the first non-singleton dimension.
ditfft: De c i ma t i o n i n t i me ( D I T ) f f t
73
UR11EC098
SOURCE CODE:(DITFFT)
clc;
clear all;
close all;
N=input('Enter the number of elements:');
for i=1:N
re(i)= input('Enter the real part of the element:');
im(i)= input('Enter the imaginary part of the element:');
end
%% Call Dit_fft function
[re1,im1]= ditfft(re,im,N);
74
UR11EC098
disp(re1);
disp(im1);
figure(1);
subplot(2,2,1);
stem(re1);
xlabel('Time period');
ylabel('Amplitude');
title('Real part of the output');
subplot(2,2,2);
stem(im1);
xlabel('Time period');
ylabel('Amplitude');
title('Imaginary part of the output');
%%dit_ifft
N=input('Enter the number of elements:');
for i=1:N
re(i)= input('Enter the real part of the element:');
im(i)= input('Enter the imaginary part of the element:');
end
for i=1:N
re(i)=re(i);
im(i)=-im(i);
end
%% call dit_ifft function
[re1,im1]=ditifft(re,im,N);
for i=1:N
re1(i)=re1(i)/N;
im1(i)=-im1(i)/N;
end
disp(re1);
disp(im1);
%figure(2)
subplot(2,2,3);
stem(re1);
xlabel('Time period');
ylabel('Amplitude');
75
UR11EC098
UR11EC098
ur=1;
ui=0;
sr=cos(pi/le2);
si=sin(pi/le2);
for j=2:(le2+1)
jm=j-1;
for i=jm:le:N
ip=i+le2;
tr=re(ip)*ur-im(ip)*ui;
ti=re(ip)*ui-im(ip)*ur;
re(ip)=re(i)-tr;
im(ip)=im(i)-ti;
re(i)=re(i)+tr;
im(i)=im(i)+ti;
end
tr=ur;
ur=tr*sr-ui*si;
ui=tr*si+ui*sr;
end
end
Function Table:(DITIFFT)
function [ re,im] = ditifft(re,im,N)
%UNTITLED2 Summary of this function goes here
% Detailed explanation goes here
N1=N-1;
N2=N/2;
j=N2+1;
M=log2(N);
%Bit reversal sorting
for i=2:N-2
if i<j
tr=re(j);
ti=im(j);
re(j)=re(i);
im(j)=im(i);
re(i)=tr;
77
UR11EC098
im(i)=ti;
end
k=N2;
while k<=j
j=j-k;
k=k/2;
end
j=j+k;
j=round(j);
end
for l=1:M
le=2.^l;
le2=le/2;
ur=1;
ui=0;
sr=cos(pi/le2);
si=-sin(pi/le2);
for j=2:(le2+1)
jm=j-1;
for i=jm:le:N
ip=i+le2;
tr=re(ip)*ur-im(ip)*ui;
ti=re(ip)*ui+im(ip)*ur;
re(ip)=re(i)-tr;
im(ip)=im(i)-ti;
re(i)=re(i)+tr;
im(i)=im(i)+ti;
end
tr=ur;
ur=tr*sr-ui*si;
ui=tr*si+ui*sr;
end
end
end
78
UR11EC098
Command Window:
Output:
79
UR11EC098
UR11EC098
re(i)=re(i);
im(i)=-im(i);
end
%% Call dif_ifft function
[re1, im1]=ditifft(re,im,N);
for i=1:N
re1(i)=re1(i)/N;
im1(i)=-im1(i)/N;
end
display(re1)
display(im1);
% figure(2);
subplot(2,2,3);
stem(re1);
xlabel('Time');
ylabel('Amplitude');
title('Real part of the output');
subplot(2,2,4);
stem(im1);
xlabel('Time');
ylabel('Amplitude');
title('Imaginary part of the output');
Function Table:(DIFFFT)
function [re, im ] = diffft(re, im, N)
%UNTITLED5 Summary of this function goes here
% Detailed explanation goes here
N1=N-1;
N2=N/2;
M=log2(N);
%%
%
for l=M:-1:1;
le=2.^l;
le2=le/2;
ur=1;
ui=0;
81
UR11EC098
sr=cos(pi/le2);
si=-sin(pi/le2);
for j=2:(le2+1)
jm=j-1;
for i=jm:le:N
ip=i+le2;
tr=re(ip);
ti=im(ip);
re(ip)=re(i)-re(ip);
im(ip)=im(i)-im(ip);
re(i)=re(i)+tr;
im(i)=im(i)+ti;
tr=re(ip);
re(ip)=re(ip)*ur-im(ip)*ui;
im(ip)=im(ip)*ur+tr*ui;
end
tr=ur;
ur=tr*sr-ui*si;
ui=tr*si+ui*sr;
end
end
j=N2+1;
for i=2:N-2
if i<j
tr=re(j);
ti=im(j);
re(j)=re(i);
im(j)=im(i);
re(i)=tr;
im(i)=ti;
end
k=N2;
while k<=j
j=j-k;
k=k/2;
end
j=j+k;
end
82
UR11EC098
Function Table:(DIFIFFT)
function [ re, im ] = dififft( re, im, N)
%UNTITLED5 Summary of this function goes here
% Detailed explanation goes here
N1=N-1;
N2=N/2;
M=log2(N);
%%
%
for l=M:-1:1;
le=2.^l;
le2=le/2;
ur=1;
ui=0;
sr=cos(pi/le2);
si=-sin(pi/le2);
for j=2:(le2+1)
jm=j-1;
for i=jm:le:N
ip=i+le2;
tr=re(ip);
ti=im(ip);
re(ip)=re(i)-re(ip);
im(ip)=re(i)-re(ip);
re(i)=re(i)+tr;
im(i)=im(i)+ti
tr=re(ip);
re(ip)=re(ip)*ur-im(ip)*ui;
im(ip)=im(ip)*ur+tr*ui;
end
tr=ur;
ur=tr*sr-ui*si;
ui=tr*si+ui*sr;
end
end
j=N2+1;
for i=2:N-2
if i<j
83
UR11EC098
tr=re(j);
ti=im(j);
re(j)=re(i);
im(j)=im(i);
re(i)=tr;
im(i)=ti;
end
k=N2;
while k<=j
j=j-k;
k=k/2;
end
j=j+k;
end
Command Window:
Enter the number of points in DIF DFT:4
Enter the real part of the element:1
Enter the imaginary part of the element:0
Enter the real part of the element:1
Enter the imaginary part of the element:0
Enter the real part of the element:1
Enter the imaginary part of the element:0
Enter the real part of the element:1
Enter the imaginary part of
the element:0 re1 =
4
im1 =
0
UR11EC098
im1 =
0
Output:
85
UR11EC098
RESULT:
The DFT and IDFT of the given sequence are computed using FFT
algorithm both DITFFT and DIFFFT.
86
UR11EC098
FLOWCHART:
START
STOP
87
UR11EC098
EX. NO :8
DATE :10-2-14
AIM:
Write a MATLAB Script to design a low pass FIR filter using
Window Method for the given specifications
.
APPARATUS REQUIRED:
PC, MATLAB software
THEORY:
A digital filter is a discrete time LTI system. It is classified based on
the length of the impulse response as
IIR filters:
Where h [n] has infinite number of samples and is recursive type.
FIR filters:
They are non-recursive type and h [n] has finite number of samples.
The transfer function is of the form:
N 1
H ( z ) hn z n
n 0
This implies that it has (N-1) zeros located anywhere in the z-plane
and (N-1) poles at Z = h.
88
UR11EC098
Most of the FIR design methods are interactive procedures and hence
require more memory and execution time. Also implementation of narrow
transition band filter is costly. But there are certain reasons to go for FIR.
TYPES OF WINDOWS:
1. Rectangular
2. Triangular
3. Hamming
4. Hanning
5. Blackman
6. Kaiser
LIBRARY FUNCTIONS:
fir1 FIR filter design using the Window method.
B = fir1(N,Wn) designs an Nth order low pass FIR digital filter and
returns the filter coefficients of vector B of length (N+1). The cut-off
frequency Wn must be between
0 < Wn < 1.0, with 1.0
corresponding to half the sample rate. The filter B is real and has
linear phase. The normalized gain of the filter at Wn is -6 dB.
B = fir1(N,Wn,'high') designs an Nth order high pass filter. You can
also use
B = fir1(N,Wn,'low') to design a low pass filter.
If Wn is a two-element vector, Wn = [W1 W2], fir1 returns an order N
band pass filter with pass band W1 < W < W2.You can also specify B
= fir1(N,Wn,'bandpass'). If Wn = [W1 W2], B = fir1(N,Wn,'stop')
will design a band-stop filter.
If Wn is a multi-element vector, Wn = [W1 W2 W3 W4 W5 ... WN],
fir1 returns a N-order multi-band filter with
bands 0 < W < W1, W1 < W < W2, ..., WN < W < 1.
B = fir1(N,Wn,'DC-1') makes the first band a pass band.
B = fir1(N,Wn,'DC-0') makes the first band a stop band.
B = fir1(N,Wn,WIN) designs an N-th order FIR filter using the vector
WIN of (N+1) length to window the impulse response. If empty or
omitted, fir1 uses a Hamming window of length N+1. For a complete
list of available windows, see the Help for the WINDOW function.
89
UR11EC098
UR11EC098
ALGORITHM/PROCEDURE:
1.
Source code :1
%windows technique of Rectangular window using low pass filter
clc;
clear all;
close all;
N=input('Size of window:');
wc=input('Cut off frequency:');
h=fir1(N-1,wc/pi,boxcar(N));
tf(h,1,1,'variable','z^-1');
freqz(h);
xlabel('Frequency');
ylabel('Magnitude');
title('FIR Filter');
Source code :2
%windows technique of Triangular(Bartlet Window) using High pass filter
clc;
clear all;
close all;
91
UR11EC098
N=input('Size of window:');
wc=input('Cut off frequency:');
h=fir1(N-1,wc/pi,'high',triang(N));
tf(h,1,1,'variable','z^-1');
freqz(h);
xlabel('Frequency');
ylabel('Magnitude');
title('FIR Filter');
Source code :3
%windows technique of Hamming using Band pass filter
clc;
clear all;
close all;
N=input('Size of window:');
wc1=input('Lower Cut off frequency:');
wc2=input('Upper Cut off frequency:');
wc=[wc1 wc2];
h=fir1(N-1,wc/pi,'bandpass',hamming(N));
tf(h,1,1,'variable','z^-1');
freqz(h);
xlabel('Frequency');
ylabel('Magnitude');
title('FIR Filter');
Source code :4
%windows technique of Hanning using Band stop filter
clc;
clear all;
close all;
N=input('Size of window:');
wc1=input('Lower Cut off frequency:');
wc2=input('Upper Cut off frequency:');
wc=[wc1 wc2];
h=fir1(N-1,wc/pi,'stop',hanning(N));
tf(h,1,1,'variable','z^-1');
freqz(h);
xlabel('Frequency');
92
UR11EC098
ylabel('Magnitude');
title('FIR Filter');
Source code :5
%windows technique of Blackman window using low pass filter
clc;
clear all;
close all;
N=input('Size of window:');
wc=input('Cut off frequency:');
h=fir1(N-1,wc/pi,blackman(N));
tf(h,1,1,'variable','z^-1');
freqz(h);
xlabel('Frequency');
ylabel('Magnitude');
title('FIR Filter');
Command Window :1
Output:1
93
UR11EC098
Command Window :2
OUTPUT: 2
Command Window :3
94
UR11EC098
Output:3
Command Window :4
Output:4
95
UR11EC098
Command Window :5
Output:
RESULT:
The given low pass filter was designed using Window method and
manually verified filter co-efficient of the filters.
96
UR11EC098
FLOWCHART:
START
STOP
97
UR11EC098
EX. NO : 9
DATE: 17-02-14
AIM:
Write a MATLAB Script to design Analog Butterworth filters for the
given specifications.
APPARATUS REQUIRED:
PC, MATLAB software
THEORY:
BUTTERWORTH FILTER:
Low pass Analog Butterworth filters are all pole filters characterised
by magnitude frequency response by
2
H ( j ) =
1
1
2N
UR11EC098
LIBRARY FUNCTIONS:
butter: Butterworth digital and analog filter design.
[B, A] = butter (N,Wn) designs an Nth order Low pass digital
Butterworth filter and returns the filter coefficient vectors B
(numerator) and A (denominator) in length N+1. The coefficients are
listed in descending powers of z. The cut-off frequency Wn must be in
the range 0.0 < Wn < 1.0, with 1.0 corresponding to half the sample
rate.
butter (N,Wn,'s'),butter (N,Wn,'low','s'),butter (N,Wn,'high','s'),butter
(N,Wn,'pass','s')and butter (N,Wn,'stop','s')design analog Butterworth
filters. In this case, Wn is in [rad/s] and it can be greater than 1.0.
buttord: Butterworth filter order selection.
[N, Wn] = buttord (Wp, Ws, Rp, Rs) returns the order N of the
lowest order digital Butterworth filter that loses no more than Rp dB
in the pass band and has at least Rs dB of attenuation in the stop
band. Wp and Ws are the pass band and stop band edge frequencies,
normalized from 0 to 1 (where 1 corresponds to pi radians/sample).
For example,
Lowpass: Wp = .1,
Ws = .2
Highpass: Wp = .2,
Ws = .1
UR11EC098
[N, Wn] = buttord (Wp, Ws, Rp, Rs, 's') does the computation for
an analog filter, in which case Wp and Ws are in radians/second.
When Rp is chosen as 3 dB, the Wn in BUTTER is equal to Wp in
BUTTORD.
angle : Phase angle.
Theta=angle (H) returns the phase angles, in radians, of a matrix with
complex elements.
freqs : Laplace-transform (s-domain) frequency response.
H = freqs(B,A,W) returns the complex frequency response vector H
of the filter B/A:
B(s)
H(s) = ---- =
A(s)
100
UR11EC098
ALGORITHM/PROCEDURE:
1. Click on the MATLAB icon on the desktop (or go to Start All
programs and click on MATLAB) to get into the Command Window.
2. Type edit in the MATLAB prompt >> that appears in the
Command window.
3. Write the program in the Edit window and save it in M-file.
4. Run the program.
5. Enter the input in the command window.
6. The result is displayed in the Command window and the graphical
output is displayed in the Figure Window.
Butterworth Filters
SOURCE CODE:1
clc;
clear all;
close all;
%% Butterworth low pass Filter
% Filter Specifications
k1=input('Enter the passband gain in db:');
k2=input('Enter the stopband gain in db:');
w1=input('Enter the passband edge frequency in rad/Sec:');
w2=input('Enter the stopband edge frequency in rad/Sec:');
%Find the order and Cutofrf frequency using the given specification of
%filter
[n,Wc]=buttord(w1,w2,k1,k2,'s');
disp('The order is:');
disp(n);
disp('The cutoff frequency is:');
disp(Wc);
% Low pass filtering
[b,a]=butter(n,Wc,'low','s');
101
UR11EC098
UR11EC098
UR11EC098
clear all;
close all;
%% Bandstop Filter Specifications
Wp=input('Enter the pass band edge frequency : ');
Ws=input('Enter the stop band edge frequency : ');
Rp=input('Enter the Pass band ripple: ');
Rs=input('Enter the stop band gain: ');
%To find order of the filter
[N]=buttord(Wp,Ws,Rp,Rs,'s')
%To find cut off frequency
Wc=[Wp Ws];
%Band stop Filtering
[b,a]=butter(N,Wc,'stop','s');
%plotting magnitude and phase response
figure(1);freqs(b,a);
Command Windows :
Using Low pass filter
104
UR11EC098
105
UR11EC098
OUTPUTS:
Using Low pass filter
106
UR11EC098
107
UR11EC098
RESULT:
Analog Butterworth Filter is designed for the given specifications, and
manually verified the order, cut off frequency and filter co-efficient of the
filter.
108
UR11EC098
FLOWCHART:
START
STOP
109
UR11EC098
EX. NO : 10
DATE: 17-02-14
AIM:
Write a MATLAB Script to design Analog Chebyshev filter for the
given specifications.
APPARATUS REQUIRED:
PC, MATLAB software
THEORY:
Chebyshev Filters :
There are two types of Chebyshev filters.
Type I are all-pole filters that exhibit equi-ripple behaviour in pass band and
monotonic characteristics in stop band.
Type II are having both poles and zeros and exhibit monotonic behavior in
pass band and equi-ripple behavior in stop band. The zero lies on the
imaginary axis.
The magnitude-squared function is given as
H ( j )
1
2
1 2C N
( / p )
110
x 1
x 1
UR11EC098
LIBRARY FUNCTIONS:
cheb1ord: Chebyshev Type I filter order selection.
[N, Wn] = cheb1ord (Wp, Ws, Rp, Rs) returns the order N of the
lowest order digital Chebyshev Type I filter that loses no more than
Rp dB in the pass band and has at least Rs dB of attenuation in the
stop band.
Wp and Ws are the pass band and stop band edge
frequencies, normalized
from 0 to 1 (where 1 corresponds to pi
radians/sample). For example,
Lowpass: Wp = .1,
Highpass: Wp = .2,
Ws = .2
Ws = .1
111
UR11EC098
CHEBYSHEV FILTERS :
Source code:1
clc;
clear all;
close all;
%% Chebyshev low pass Filter
% Filter Specifications
k1=input('Enter the passband ripple in db:');
112
UR11EC098
UR11EC098
Source code: 3
clc;
clear all;
close all;
%% Bandpass Filter Specifications
Wp=input('Enter the pass band edge frequency : ');
Ws=input('Enter the stop band edge frequency : ');
Rp=input('Enter the Pass band ripple: ');
Rs=input('Enter the stop band gain: ');
%To find order of the filter
[N]=cheb1ord(Wp,Ws,Rp,Rs,'s')
%To find cut off frequency
Wc=[Wp Ws];
%Band pass Filtering
[b,a]=cheby1(N,Rp,Wc,'bandpass','s');
%plotting magnitude and phase response
figure(1);freqs(b,a);
Source code: 4
clc;
clear all;
close all;
%% Bandstop Filter Specifications
Wp=input('Enter the pass band edge frequency : ');
Ws=input('Enter the stop band edge frequency : ');
Rp=input('Enter the Pass band ripple: ');
Rs=input('Enter the stop band gain: ');
%To find order of the filter
[N]=cheb1ord(Wp,Ws,Rp,Rs,'s')
%To find cut off frequency
Wc=[Wp Ws];
%Bandstop Filtering
114
UR11EC098
[b,a]=cheby1(N,Rp,Wc,'stop','s');
%plotting magnitude and phase response
figure(1);freqs(b,a);
Command Window :1(LPF)
Output:
115
UR11EC098
Output:
116
UR11EC098
Output:
Output:
117
UR11EC098
RESULT:
Analog Chebyshev Filter is designed for the given specifications, and
manually verified the order, cut off frequency and filter co-efficient of the
filter.
118
UR11EC098
FLOWCHART:
START
STOP
119
UR11EC098
EX. NO : 11
DATE: 03-03-14
AIM:
Write a MATLAB Script to design Butterworth and Chebyshev low
pass filters using
Bilinear Transformation
Impulse Invariant Transformation
.
APPARATUS REQUIRED:
PC, MATLAB software
THEORY:
A digital filter is a linear time invariant discrete time system. The
digital filters are classified into two, based on their lengths of impulse
response
1. Finite Impulse response (FIR)
They are of non-recursive type and h [n] has finite number of
samples
2. Infinite Impulse response (IIR)
h[n] has finite number of samples. They are of recursive type.
Hence, their transfer function is of the form
H ( z ) h( n) z n
n 0
M 1
bk Z k
H (Z ) K 0
1
N 1
a jZ j
j 1
120
UR11EC098
The digital filters are designed from analog filters. The two widely
used methods for digitizing the analog filters include
1. Bilinear transformation
2. Impulse Invariant transformation
The bilinear transformation maps the s-plane into the z-plane by
H(Z) = H ( S ) | s
2 1 Z 1
T 1 Z 1
2
tan
T
2
BILINEAR TRANSFORMATION:
DESIGN STEPS:
1. From the given specifications, Find pre-warped analog
frequencies using
2
tan
T
2
2 1 Z 1
in the H(s) of Step:2
T 1 Z 1
= /T
121
UR11EC098
H (Z )
Ck
k 1
1 e
TPk Z 1
LIBRARY FUNCTIONS:
Impinvar: Impulse Invariant method for analog-to-digital filter
conversion [bz,az] = impinvar(b,a,fs) creates a digital filter with
numerator and denominator coefficients bz and az, respectively,
whose impulse response is equal to the impulse response of the analog
filter with coefficients b and a, scaled by 1/fs. If you leave out the
argument fs (or) specify fs as an empty vector [ ], it takes the default
value of 1 Hz.
Bilinear: Bilinear transformation method for analog-to-digital filter
conversion. The bilinear transformation is a mathematical mapping of
variables. In digital filtering, it is a standard method of mapping the s
or analog plane into the z or digital plane. It transforms analog filters,
designed using classical filter design
122
UR11EC098
ALGORITHM/PROCEDURE:
SOURCE CODE:
/ Butterworth Lowpass Impulse invariant method
clc;
clear all;
close all;
warning off;
% Design of IIR Filters
%% Filter Specifications
% Input Wp,Ws,Sp,Ss,T
% T=1,bothe ripple gains should be b/w .1 to .3
disp(' Butterworth Lowpass filter using Impulse invariant method
');
123
UR11EC098
ohmp=Wp/T;
ohms=Ws/T;
% Butterworth Filter
% Calculation of order and cutoff freq. for the above filter specs.
[n,Wc]=buttord(ohmp,ohms,Ap,As,'s');
% Low Pass Filtering
[b,a]=butter(n,Wc,'low','s');
[bz,az] = impinvar(b,a,T);
tf(bz,az,T);
O=linspace(-pi,pi,50);
% O is the freq. axis
H=freqz(bz,az,O);
% Magnitude Response
Hm=20*log10(abs(H));
subplot(2,1,1);
semilogx(O,Hm);
xlabel('Frequency');
ylabel('Magnitude');
title('Magnitude Response of IIR Filter using Impulse Invariant Method');
% Phase Response
Ha=angle(H);
subplot(2,1,2);
semilogx(O,Ha);
xlabel('Frequency');
ylabel('Phase');
title('Phase Response of IIR Filter using Impulse Invariant Method');
UR11EC098
UR11EC098
xlabel('Frequency');
ylabel('Phase');
title('Phase Response of IIR Filter using Bilinear Transformation Method');
');
UR11EC098
% Magnitude Response
Hm=20*log10(abs(H));
subplot(2,1,1);
semilogx(O,Hm);
xlabel('Frequency');
ylabel('Magnitude');
title('Magnitude Response of IIR Filter using Impulse Invariant Method');
% Phase Response
Ha=angle(H);
subplot(2,1,2);
semilogx(O,Ha);
xlabel('Frequency');
ylabel('Phase');
title('Phase Response of IIR Filter using Impulse Invariant Method');
UR11EC098
ohms=Ws/T;
% Chebyshev Filter
% Calculation of order and cutoff freq. for the above filter specs.
[n,Wc2]=cheb1ord(ohmp,ohms,Ap,As,'s')
% Low Pass Filtering
[b,a]=cheby1(n,Ap,Wc2,'low','s');
[bz,az] = bilinear(b,a,1/T);
tf(bz,az,T);
O=linspace(-pi,pi,50);
% O is the freq. axis
H=freqz(bz,az,O);
% Magnitude Response
Hm=20*log10(abs(H));
subplot(2,1,1);
semilogx(O,Hm);
xlabel('Frequency');
ylabel('Magnitude');
title('Magnitude Response of IIR Filter using Bilinear Transformation
Method');
% Phase Response
Ha=angle(H);
subplot(2,1,2);
semilogx(O,Ha);
xlabel('Frequency');
ylabel('Phase');
title('Phase Response of IIR Filter using Bilinear Transformation Method');
128
UR11EC098
Output:
129
UR11EC098
Output:
130
UR11EC098
Output:
131
UR11EC098
Output:
132
UR11EC098
RESULT:
Butterworth and Chebyshev Lowpass filters were designed using
Bilinear and Impulse Invariant transformations, and manually verified the
order, cut off frequency and filter co-efficient of the filters.
133
UR11EC098
FLOWCHART:
START
STOP
134
UR11EC098
EX. NO :12(A)
DATE:10-03-14
AIM:
Write a MATLAB Script to find the time domain response (impulse
response and step response) for the given FIR and IIR systems (filters).
.
APPARATUS REQUIRED:
PC, MATLAB software
THEORY:
IMPULSE RESPONSE:
[n]
y1[n]=T[[n]]=h[n]
If the input to the system is a unit impulse (ie) x[n] = [n], then the
output of the system, known as the impulse response, is denoted by h [n]
where,
h[n]=T[[n]]
STEP RESPONSE:
u[n]
y2[n]=T[u[n]]=s[n]
If the input to the system is a unit step (ie) x[n] = u[n], then the output
of the system, known as step response, is denoted by s[n] where,
135
UR11EC098
s[n]=T[u[n]]
The relation between the impulse response and step response is given
by
s[n]
= u[n]*h[n]
LIBRARY FUNCTIONS:
filter: Filters data with an infinite impulse response (IIR) or
finite impulse
response (FIR) filter .The filter function filters a data sequence using a
digital filter which works for both real and complex inputs. The filter
is a direct form II transposed implementation of the standard
difference equation.
y = filter (b, a, X) filters the data in vector X with the filter
described by numerator coefficient vector b and denominator
coefficient vector a. If a(1) is not equal to 1, filter normalizes the filter
coefficients by a(1). If a(1) equals 0, filter returns an error.
ALGORITHM/PROCEDURE:
1. Click on the MATLAB icon on the desktop (or go to Start All
Programs and click on MATLAB) to get into the Command Window
2. Type edit in the MATLAB prompt >> that appears in the
Command window.
3. Write the program in the Edit window and save it in M-file
4. Run the program
5. Enter the input in the command window
136
UR11EC098
UR11EC098
subplot(2,2,3), stem(k1,x1,'r');
xlabel('Time');
ylabel('Unit Impulse');
title('Impulse input');
subplot(2,2,4), stem(k1,y1,'r');
xlabel('Frequency');
ylabel('Magnitude');
title('Impulse Response IIR Filter');
PROGRAM 2
clc;
clear all;
close all;
%% Input the samples
% Time domain Response of FIR filter
N=16; %Input samples
k=0:N-1;
x(1:N)=1;
b0=1; b1= -1; b2=-2;
B=[b0,b1,b2]; %Numerator coeff.
A=1; %Denominator coeff.
%Filtering
y=filter(B, A ,x);
%plot the graph
subplot(2,2,1);
stem(k,x,'r');
xlabel('Time');
ylabel('Unit step signal');
title('Unit step input signal');
subplot(2,2,2);
stem(k,y,'r');
xlabel('Frequency');
ylabel('Magnitude');
title('Step Response FIR filter');
% Time domain response of IIR filter
N1=10; %Input samples
k1=0:N1-1;
x1(1:N1)=1;
B1=1;
138
UR11EC098
a=0.8;
A1=[1,-a];
y1=filter(B1, A1 ,x1);
%plot the graph
subplot(2,2,3);
stem(k1,x1,'r');
xlabel('Time');
ylabel('Unit step input');
title('Unit step input signal');
subplot(2,2,4);
stem(k1,y1,'r');
xlabel('Frequency');
ylabel('Magnitude');
title('Step Response IIR Filter');
Output for Unit impulse input:
139
UR11EC098
RESULT:
The Time domain responses of the given systems were found using
MATLAB and manually verified.
140
UR11EC098
FLOWCHART:
START
STOP
141
UR11EC098
EX. NO : 12(B)
DATE:10-03-14
AIM:
Write a MATLAB Script to find the frequency domain response
(magnitude response and phase response) for the given FIR and IIR systems
(filters).
.
APPARATUS REQUIRED:
PC, MATLAB software
THEORY:
IMPULSE RESPONSE:
T
T
x[n]
y[n]=T[x[n]]
If the input to the system is a unit impulse (ie) x[n]=[n], then the
output of the system is known as impulse response denoted by h[n] where,
h[n]=T[[n]]
We know that any arbitrary sequence x[n] can be represented as a
weighted sum of discrete impulses. Now the system response is given by,
y[n]=T[x[n]]= T[
x(k ) (n k ) ]
142
UR11EC098
where x(k) denotes the kth sample. The response of DTLTI system to
sequence x(k) [n-k] will be x(k)h[n-k].i.e. T[x(k) [n-k]] = x(k) T[[n-k]] =
x(k) h[n-k].So response y[n] of DTLTI system to x[n] is
= x[n]*h[n]
h( k ) x ( n k )
If x[n] is a complex exponential of the form x[n] =ejn where n varies from to
jk
.e jn h(k )
jk
h(k )e jwn
y[n]=H(ej) ejn
143
UR11EC098
LIBRARY FUNCTIONS:
exp: Exponential.
exp (X) is the exponential of the elements of X, e to the power X. For
complex Z=X+i*Y, exp (Z) = exp (X)*(COS(Y) +i*SIN(Y)).
disp: Display array.
DISP (X) is called for the object X when the semicolon is not used to
terminate a statement.
Freqz: Compute the frequency response of discrete-time filters,
[h,w] = freqz (hd) returns the frequency response vector h and the
corresponding frequency vector w for the discrete-time filter hd.
When hd is a vector of discrete-time filters, freqz returns the matrix h.
Each column of h corresponds to one filter in the vector hd.
Angle: Phase angle
P = angle (Z) returns the phase angle, in radians, for each element of
complex array Z.
log10:
The log10 function operates element-by-element on arrays. Its domain
includes complex numbers, which may lead to unexpected results if
used unintentionally
ALGORITHM/PROCEDURE:
1. Click on the MATLAB icon on the desktop (or go to Start All
programs and click on MATLAB) to get into the Command Window
2. Type edit in the MATLAB prompt >> that appears in the
Command window.
3. Write the program in the Edit window and save it in M-file.
4. Run the program.
144
UR11EC098
SOURCE CODE:
clc;
clear all;
close all;
%Frequency Response
num=input('Enter num:');
denum=input('Enter denum:');
n=linspace(0,pi,1000);
h=freqz(num,denum,n);
mag=20*log(abs(h));
subplot(2,2,1),semilogx(n,mag);
xlabel('Frequency index'),ylabel('Magnitude'),title('Magnitude Response');
pha=angle(h);
subplot(2,2,2),semilogx(n,pha);
xlabel('Frequency index'),ylabel('Phase'),title('Phase Response');
z=tf(num,denum,1)
COMMAND WINDOW:
145
UR11EC098
OUTPUT :
RESULT:
The frequency response (magnitude and phase response) of the given
system was found using MATLAB.
146
UR11EC098