DIgital Signal Processing Lab Manual

FLOWCHART:
START
ENTER THE SIGNAL
PARAMETERS (AMPLITUDE,
TIME AND FREQUENCY)
GENERATE THE WAVEFORM BY USING

THE APPROPRIATE LIBRARY FUNCTION
PLOT THE WAVEFORMS
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,
2. Unit step sequence,
2. Unit step signal
3. Unit Ramp sequence,
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
Unit impulse sequence. x (n) (n)
1, for n 0
0, otherwise
Unit step sequence. x (n) u(n)
n, for n 0
0, otherwise
Unit ramp sequence. x (n) r (n)
Sinusoidal sequence. x(n) A sin(n ) .

2
UR11EC098
Exponential sequence. x(n) = A an, where A and a are constant.

Continuous time signals:
1, for t 0
Unit impulse signal. x (t ) (t ) 0, otherwise
1, for t 0
x (t ) u(t )
0, otherwise
Unit step signal.
Unit ramp signal.
t , for t 0
x (t ) r (t )
0, otherwise
Sinusoidal signal. x(t ) A sin t ) .

( at
Exponential signal. x ( t ) = A e , where A and a are constant.
a
t
LIBRARY FUNCTIONS:
clc:
CLC Clear command window.
CLC clears the command window and homes the cursor.
clear all:
CLEAR Clear variables and functions from memory. CLEAR
removes all
variables from the workspace.CLEAR VARIABLES does the same
thing.
close all:
CLOSE Close figure.CLOSE, by itself, closes the current figure
window.
CLOSE ALL closes all the open figure windows.
exp:
EXP Exponential.
EXP(X) is the exponential of the elements of X, e to the X.
input:
INPUT Prompt for user input.
3
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');
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');
title('Exponential signal');
%UNIT RAMP SIGNAL
t4=-10:1:20;
x4=t4;
subplot(2,3,4);
plot(t4,x4);
xlabel('time');
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');
title('Sinusoidal signal');
%RANDOM SIGNAL
t6=-10:1:20;
x6=rand(1,31);
6
UR11EC098
subplot(2,3,6);
plot(t6,x6);
xlabel('time');
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');
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');
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');
title('Exponential signal');
%UNIT RAMP SIGNAL
n4=-10:1:20;
x4=n4;
subplot(2,3,4);
7
UR11EC098
stem(n4,x4);
xlabel('time');
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');
%RANDOM SIGNAL
n6=-10:1:20;
x6=rand(1,31);
subplot(2,3,6);
stem(n6,x6);
xlabel('time');
title('Random signal');
CONTINUOUS TIME:
UR11EC098
DISCRETE TIME :
OUTPUT WAVEFORM(CONTINUOUS TIME):
UR11EC098
OUTPUT WAVEFORM (DISCRETE TIME):
RESULT:
The program to generate various waveforms is written, executed
and the output is verified.
10
UR11EC098
FLOWCHART:
START
READ THE INPUT

SEQUENCE
READ THE CONSANT FOR
(SCALAR) AMPLITUDE
AND TIME
MANIPULATION
READ THE (VECTOR)
SEQUENCE FOR SIGNAL
ADDTION AND
MULTIPLICATION
PERFORM OPERTAION ON THE D.T. SIGNAL
PLOT THE WAVEFORMS
STOP
11
UR11EC098
EX. NO :2
DATE :21-12-13
BASIC OPERATIONS ON D.T SIGNALS
AIM:
Write a program in MATLAB to study the basic operations on the

Discrete time signals. (Operation on dependent variable (amplitude
manipulation) and Operation on independent variable (time manipulation)).
APPARATUS REQUIRED:

THEORY:
Let x(n) be a sequence with finite length.

1. Amplitude manipulation
Amplitude scaling:y[n] =ax[n], where a is a constant.
If a > 1, then y[n] is amplified sequence
If a < 1, then y[n] is attenuated sequence
If a = - 1, then y[n] is amplitude reversal sequence
Offset the signal: y[n] =a+x[n], where a is a constant
Two signals x1[n] and x2[n] can also be added and multiplied: By
adding the values y1[n]= x1[n] + x2[n] at each corresponding sample
and
by multiplying the values y2[n]= x1[n] X x2[n]
at each
corresponding sample.
2. Time manipulation
Time scaling:
y[n]=x[an], where a is a constant.
Time shifting:
y[n]=x[n - ], where is a constant.
Time reflection (folding):y[n]=x[-n]

12
UR11EC098
Arithmetic Operations
*
Matrix multiplication
.*
Array multiplication (element-wise)
LIBRARY FUNCTIONS:
date Current date as date string.
S = date returns a string containing the date in dd-mmm-yyyy format
tic & toc Start a stopwatch timer.

The sequence of commands
TIC, operation, TOC
prints the number of seconds required for the operation.
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.
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');
title('Amplified signal');
subplot(2,2,3);
stem(0:n-1,y2);
xlabel('time');
title('Attenuated signal');
subplot(2,2,4);
stem(0:n-1,y3);
xlabel('time');
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
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');
i=n0:l+n0-1;
j=n1:l+n1-1;
subplot(2,2,2);
stem(i,x);
xlabel('time');
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');
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');
title('Input sequence 1');
subplot(2,2,2);
stem(0:l2-1,x2);
xlabel('time');
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');
title('Addition of two signals');
y2=x1.*x2;
subplot(2,2,4);
stem(0:l1-1,y2);
xlabel('time');
title('Multiplication of two signals');
end
if l2>l1
l3=l2-l1;
y1=x1+x2;
subplot(2,2,3);
16
UR11EC098
stem(0:l2-1,y1);
xlabel('time');
y2=x1.*x2;
subplot(2,2,4);
stem(0:l2-1,y2);
xlabel('time');
else
y1=x1+x2;
subplot(2,2,3);
stem(0:l1-1,y1);
xlabel('time');
y2=x1.*x2;
subplot(2,2,4);
stem(0:l1-1,y2);
xlabel('time');
end
operations on the amplitude of signal :
17
UR11EC098
Time shifting of the independent variable :
Addition and multiplication of two signals :
OUTPUT (operations on the amplitude of signal ):
18
UR11EC098
OUTPUT(Time shifting of the independent variable) :
19
UR11EC098
OUTPUT(Addition and multiplication of two signals) :
RESULT:
The program to perform various operations on discrete time signal is

written, executed and the output is verified
20
UR11EC098
FLOWCHART:
START
READ THE INPUT

SEQUENCE
READ THE CONSANT FOR

(SCALAR) AMPLITUDE
AND TIME
MANIPULATION
READ THE (VECTOR)

SEQUENCE FOR SIGNAL
ADDTION AND
MULTIPLICATION
PERFORM OPERTAION ON THE D.T. SIGNAL USING

THE APPROPRIATE LIBRARY FUNCTION
PLOT THE WAVEFORMS
STOP
21
UR11EC098
EX. NO : 3
DATE: 06-1-14
PROPERTIES OF DISCRETE TIME SYSTEM
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:
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
But does not depend on future inputs [x (n+1),x(n+2),..]

y(n) = F[ x(n),x(n-1),x(n-2).] F[ ] Arbitrary function.
METHODS OF PROOF:
1. If the difference equation is given, the arguments of the output y (n)
are compared with the arguments (time instant) of the input signals. In
the case of only present and past inputs, the system is causal. If future
inputs are present then the system is non-causal.
2. If the impulse response is given, then it is checked whether all the
values of h (n) for negative values of n are zero. (i.e.) if h(n)=0, for
<0. If this is satisfied, then the system is causal.
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
- to + is taken and if the sum is finite, the system
is said to be BIBO stable.

2. It the transfer function of the system is given, the poles of the transfer
function is plotted. If all the poles lie within the unit circle, the system
is stable.
A single order pole on the boundary of unit circle makes the
systems marginally stable. If there are multiple order poles on the
boundary of unit circle, the system is unstable.If any pole is lying
outside the unit circle, the system is unstable.
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.
C = POWER(A,B) is called for the syntax 'A .^ B' when A or B is an

object.
residuez Z-transform partial-fraction expansion.

[R,P,K] = residuez(B,A) finds the residues, poles and direct terms
of the partial-fraction expansion of B(z)/A(z),
zplane Z-plane zero-pole plot.

zplane(Z,P) plots the zeros Z and poles P (in column vectors) with
the unit circle for reference. Each zero is represented with a 'o' and
each pole with a 'x' on the plot.
tf Creation of transfer functions or conversion to transfer function.

SYS = tf(NUM,DEN,TS) creates a discrete-time transfer function
with sample time TS (set TS=1 to get it in z). Z = tf('z',TS) specifies
H(z) = z with sample time TS.
syms Short-cut for constructing symbolic objects.
subs Symbolic substitution. subs(S,NEW) replaces the free symbolic
variable in S with NEW.
24
UR11EC098
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');
title('First input sequence');
subplot(2,2,2);
stem(0:n-1,x2);
xlabel('Time');
title('Second input sequence');
subplot(2,2,3);
stem(0:n-1,lhs);
xlabel('Time');
title('LHS');
subplot(2,2,4);
stem(0:n-1,rhs);
xlabel('Time');
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');
title('First signal');
subplot(2,2,2);
stem(x2);
xlabel('time');
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');
title('L.H.S');
subplot(2,2,4);
stem(rhs);
xlabel('time');
title('R.H.S');
Source code :3
clc;
clear all;
close all;
%Properties of DT Systems(Time Invariance)
%y(n)=x(n);
27
UR11EC098
x1=input('Enter input sequence x1:');

n0=input('Enter shift:');
x2=[zeros(1,n0),x1];
y1=x1;
y2=x2;
y3=[zeros(1,n0),y1];
if(y2==y3)
display('system is time invariant');
else
display('system is time variant');
end;
subplot(2,2,1);
stem(x1);
xlabel('time');
subplot(2,2,2);
stem(x2);
xlabel('time');
title('Signal after shift');
subplot(2,2,3);
stem(y2);
xlabel('time');
title('L.H.S');
subplot(2,2,4);
stem(y3);
xlabel('time');
title('R.H.S');
Source code :4
clc;
clear all;
close all;
28
UR11EC098
%Properties of DT Systems(Time Invariance)

%y(n)=n*[x(n)];
n1=length(x1);
for n=1:n1
y1(n1)=n.*x1(n);
end;
n0=input('Enter shift:');
x2=[zeros(1,n0),x1];
for n2=1:n1+n0
y2(n2)=n2.*x2(n2);
end;
y3=[zeros(1,n0),y1];
if(y2==y3)
display('system is time invariant');
else
display('system is time variant');
end;
subplot(2,2,1);
stem(x1);
xlabel('time');
subplot(2,2,2);
stem(x2);
xlabel('time');
title('Signal after shift');
subplot(2,2,3);
stem(y2);
xlabel('time');
title('L.H.S');
subplot(2,2,4);
stem(y3);
xlabel('time');
title('R.H.S');
29
UR11EC098
Source code :5
clc;
clear all;
close all;
%Properties of DT Systems(Causality)
%y(n)=x(-n);
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
Time invariant system :3
Output :
33
UR11EC098
Time variant system : 4
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
ENTER THE SIGNAL

PARAMETERS (AMPLITUDE,
TIME AND FREQUENCY)
PERFORM THE SAMPLING RATE CONVERSION

ON THE INPUT BY USING UPSAMPLE,
DOWNSAMPLE AND RESAMPLE
PERFORM INTERPOLATION AND DECIMATION

ON THE INPUT
FIND THE SPECTRUM OF

ALL THE SIGNALS
PLOT THE WAVEFORMS
STOP
37
UR11EC098
EX. NO : 4
DATE: 13-1-14
SAMPLING RATE CONVERSION
AIM:
Write a MATLAB Script to perform sampling rate conversion for any

given arbitrary sequence (D.T) or signal (C.T) by interpolation, decimation,
upsampling, downsampling and resampling (i.e. fractional value)
.
APPARATUS REQUIRED:
PC, MATLAB software
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;
T period of the 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
a sequence with a sampling rate of F Hz and it is used to generate another

sequence y[n] with desired sampling rate F Hz, then the sampling rate
alteration is given by,
F/F = R
If R > 1, the process is called interpolation and results in a sequence
with higher sampling rate. If R< 1, the process is called decimation and
results in a sequence with lower sampling rate.
DOWNSAMPLE AND DECIMATION:
Down sampling operation by an integer factor M (M>1) on a
sequence x[n] consists of keeping every Mth sample of x[n] and removing
M-1 in between samples, generating an output sequence y[n] according to
the relation
y [n] = x[nM]
y [n] sampling rate is 1/M that of x[n]
If we reduce the sampling rate, the resulting signal will be an aliased version
of x[n]. To avoid aliasing, the bandwidth of x[n] must be reduced to Fmax
=Fx/2 or max = /M. The input sequence is passed through LPF or an
antialiasing filter before down sampling.
x [n]
ANTIALIASING
FILTER H (Z)
y[n]
UPSAMPLE AND INTERPOLATION:

Upsampling by an integer factor L (L > 1) on a sequence x[n] will
insert (L1) equidistant samples between an output sequence y[n] according
to the relation
x[n/L],
y[n] = 0,
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]
SAMPLING RATE CONVERSION BY A RATIONAL FACTOR I/O:

We achieve this conversion, by first performing interpolation by the
factor I and then decimating the output of interpolator by the factor D,
interpolation has to be performed before decimation to obtain the new
rational sampling rate.
x[n]
UPSAMPLER
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:
Increases sampling rate by an integer factor
(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
upsample: Increases the sampling rate of the input signal

y = upsample(x,n) increases the sampling rate of x by inserting n-1 zeros
between samples. The upsampled y has length(x)*n samples
decimate: Decreases the sampling rate for a sequence
(decimation).
y = decimate (x, r) reduces the sample rate of x by a factor r. The decimated
vector y is r times shorter in length than the input vector x. By default,
decimate employs an eighth-order low pass Chebyshev Type I filter. It filters
the input sequence in both the forward and reverse directions to remove all
phase distortion, effectively doubling the filter order.
downsample: Decreases the sampling rate of the input signal
y = downsample(x,n) decreases the sampling rate of x by keeping every nth
sample starting with the first sample. The downsampled y has length(x)/n
samples
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');
%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');
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');
title('Interpolated signal');
%resampling the signal
y3=resample(x,3,2);
subplot(2,3,4);
stem(y3);
xlabel('time');
title('Resampled signal');
%downsampling the signal
42
UR11EC098
y4=downsample(x,2);
subplot(2,3,5);
stem(y4);
xlabel('time');
title('Downsampled signal');
%upsampling the signal
y5=upsample(x,3);
subplot(2,3,6);
stem(y5);
xlabel('time');
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
ENTER THE INPUT

SEQUENCE x[n] & SYSTEM
RESPONSE h[n]
PERFORM LINEAR AND CIRCULAR

CONVOLUTION IN TIME DOMAIN
PLOT THE WAVEFORMS AND ERROR
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.
STEPS IN LINEAR CONVOLUTION:

The process of computing convolution between x[k] and h[k] involves four
steps.
1. Folding: Fold h[k] about k=0 to obtain h[-k]
47
UR11EC098
2. Shifting: Shift h[-k] by n0to right if n0 is positive and shift h[-k]

by n0 to the left if n0 is negative. Obtain h[n0-k]
3. Multiplication : Multiply x[k] by h[n0-k] to obtain the product
sequence
yn0 [k] = x[k] h [n0 k]
4. Summation: Find the sum of all the values of the product sequence
to obtain values of output at n = n0
Repeat steps 2 to 4 for all possible time shifts n 0 in the range <n<
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
y[n] = x1[n] * x2[n] =
x 1 [(n-k) mod N] x2 (k) or

k 0
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
C = conv (A, B) convolves vectors A and B. The resulting vector Cs

length is given by length(A)+length(B)-1. If Aand B are vectors of
polynomial coefficients, convolving them is equivalent to multiplying
the two polynomials in frequency domain.
length: Length of vector.
length(X) returns the length of vector X. It is equivalent to size(X) for
non empty arrays and 0 for empty ones.
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-D
arrays, the fft operation operates on the first non-single dimension.
fft(x,N) is the N-point FFT, padded with zeros if x has less than N
points and truncated if it has more.
ifft:
Inverse Discrete Fourier transform.
ifft(X) is the Inverse Discrete Fourier transform of X.

ifft(X,N) is the N-point Inverse Discrete Fourier transform of X.
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');
title('First sequence');
x2=input('Enter the second sequence to be convoluted:');
subplot(3,1,2);
stem(x2);
xlabel('Time');
title('Second sequence');
f=conv(x1,x2);
50
UR11EC098
disp('The Linear convoluted sequence is');

disp(f);
subplot(3,1,3);
stem(f);
xlabel('Time');
title('Linear Convoluted sequence');
Command window :
OUTPUT :
51
UR11EC098
SOURCE CODE :2
clc;
clear all;
close all;
%Program to perform Circular Convolution
subplot(3,1,1);
l1=length(x1);
stem(x1);
xlabel('Time');
subplot(3,1,2);
l2=length(x2);
stem(x2);
xlabel('Time');
if l1>l2
l3=l1-l2;
elseif l2>l1
l3=l2-l1;
end
f=cconv(x1,x2);
disp('The Circular convoluted sequence is');
disp(f);
subplot(3,1,3);
stem(f);
xlabel('Time');
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
subplot(3,1,1);
l1=length(x1);
stem(x1);
xlabel('Time');
subplot(3,1,2);
l2=length(x2);
stem(x2);
xlabel('Time');
if l1>l2
l3=l1-l2;
elseif l2>l1
l3=l2-l1;
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');
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---->');
title('input sequence');
h=input('Enter the system response sequence:');
l2=length(h);
subplot(3,2,2);
stem(h);
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);
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);
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);
title('output after inverse fourier transform');
e=y-y1;
disp('The Error sequence:')
disp(abs(e));
subplot(3,2,6);
stem(abs(e));
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');
title('First sequence Response x(n)');
n=0:1:n2-1;
subplot(3,1,2);
stem(n,h);
xlabel('Time');
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');
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
ENTER THE INPUT

SEQUENCE
PERFORM THE DFT USING IN-BUILT FFT

AND USING DIRECT FORMULA ON THE
GIVEN INPUT SEQUENCE
PLOT THE WAVEFORMS AND

ERROR
STOP
62
UR11EC098
EX. NO : 6
DATE : 27-1-14
DISCRETE FOURIER TRANSFORM
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
Consider a complex series x [n] with N samples of the form

Where x is a complex number
Further, assume that the series outside the range 0, N-1 is extended Nperiodic, that is, xk = xk+N for all k. The FT of this series is denoted as X (k)
and has N samples. The forward transform is defined as
X(k)
1 N 1
j2 n k N
x(n) e
, for k 0 ... N 1
N n0
The inverse transform is defined as
Although the functions here are described as complex series, setting

the imaginary part to 0 can represent real valued series. In general, the
transform into the frequency domain will be a complex valued function, that
is, with magnitude and phase.
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
max: Maximum elements of an array

C = max (A, B) returns an array of the same size as A and B with the
largest elements taken from A or B.
fft: Discrete Fourier transform.
fft(x) is the discrete Fourier transform (DFT) of vector x. For the
matrices, the FFT operation is applied to each column. For NDimensional arrays, the FFT operation operates on the first nonsingleton dimension.
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
Command window.
3. Write the program in the Edit window and save it as m-file
4. Run the program
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);
title ('X(k)');
% To find the magnitudes of individual DFT points

magnitude=abs(Xk);
%code block to plot the magnitude response
disp('The magnitude response of X(k):');
disp(magnitude);
t=0:N-1;
subplot(3,2,3);
66
UR11EC098
stem(t,magnitude);
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);
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
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
ENTER THE INPUT

SEQUENCE IN TIME DOMAIN
OR FREQUENCY DOMAIN
PERFORM DIT/DIF-FFT FOR TIME SAMPLES
OR PERFORM IDIT/IDIT-FFT FOR
FREQUENCY SAMPLES
PLOT THE WAVEFORMS
STOP
70
UR11EC098
EX. NO :7
DATE :3-2-14
FAST FOURIER TRANSFORM ALGORITHMS
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
which may conveniently be written in the form

N 1
X (k) =
n0
nk
x(n)w N
k=0, 1.N-1
where WN=e-j2/N which is known as Twiddle or Phase factor.
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
RADIX-2 DECIMATION IN TIME FFT:

The idea is to successively split the N-point time domain
sequence into smaller sub sequence. Initially the N-point sequence is split
into xe[n] and xo[n], which have the even and odd indexed samples of
x[n] respectively. The N/2 point DFTs of these two sequences are
evaluated and combined to give N-point DFT. Similarly N/2 point
sequences are represented as a combination of two N/4 point DFTs. This
process is continued, until we are left with 2 point DFT.
RADIX-2 DECIMATION IN FREQUENCY FFT:
The output sequence X(k) is divided into smaller sequence..
Initially x[n] is divided into two sequences x1[n], x2[n] consisting of the
first and second N/2 samples of x[n] respectively. Then we find the N/2
point sequences f[n] and g[n] as
f[n]= x1[n]+x2[n],
g[n]=( x1[n]-x2[n] )wNk
The N/2 point DFT of the 2 sequences gives even and odd numbered output
samples. The above procedure can be used to express each N/2 point DFT as
a combination of two N/4 point DFTs. This process is continued until we are
left with 2 point DFT.
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
ditfft(x) is the discrete Fourier transform (DFT) of vector x in time

domain decimation
diffft: De c i ma t i o n i n f r e q u e n c y ( DI F ) f f t
diffft(x) is the discrete Fourier transform (DFT) of vector x in Frequency
domain decimation
1. Input the given sequence x[n]
2. Compute the Discrete Fourier Transform using FFT library function
(ditfft or diffft) and obtain X[k]
3. Compute the Inverse Discrete Fourier Transform using FFT library
function (ditfft or diffft) and obtain X[n] by following steps
a. Take conjugate of X [k] and obtain X[k]*
b. Compute the Discrete Fourier Transform using FFT library
function (ditfft or diffft) for X[k]* and obtain N.x[n]*
c. Once again take conjugate for N.x[n]* and divide by N to
obtain x[n]
4. Display the results.
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');
title('Real part of the output');
subplot(2,2,2);
stem(im1);
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);
75
UR11EC098

subplot(2,2,4);
stem(im1);
Function Table:(DITFFT)
function [ re, im ] = ditfft( re, im, N)
%UNTITLED5 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;
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;
76
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)
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
Source code :(DIFFFT)

%% DIF_FFT
clc;
clear all;
close all;
%%
N=input('Enter the number of points in DIF DFT:');
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 DIf_FFT Function
[re1, im1]=diffft(re,im,N);
display(re1);
display(im1);
figure(1);
subplot(2,2,1);
stem(re1);
xlabel('Time');
subplot(2,2,2);
stem(im1);
xlabel('Time');
%% DIF IFFT
N=input('Enter the number of points in DIF IFFT:');
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
80
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');
subplot(2,2,4);
stem(im1);
xlabel('Time');
Function Table:(DIFFFT)
function [re, im ] = diffft(re, im, N)
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)
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 imaginary part of
the element:0 re1 =
4
im1 =
0
Enter the number of points in DIF IFFT:4

84
UR11EC098

re1 =
1
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
ENTER THE FILTER

SPECIFICATIONS (ORDER OF
THE FILTER, CUT-OFF
FREQUENCY)
DESIGN THE FILTER
PLOT THE WAVEFORMS
STOP
87
UR11EC098
EX. NO :8
DATE :10-2-14
DESIGN OF FIR FILTERS
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.
THE FIR FILTER CAN BE DESIGNED BY:

Fourier series method
Frequency sampling method
Window method
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
KAISER and CHEBWIN can be specified with an optional trailing

argument. For example, B = fir1(N,Wn,kaiser(N+1,4)) uses a Kaiser
window with beta=4. B = fir1(N,Wn,'high',chebwin(N+1,R)) uses a
Chebyshev window with R decibels of relative sidelobe
attenuation.For filters with a gain other than zero at Fs/2, e.g., high
pass and band stop filters, N must be even. Otherwise, N will be
incremented by one. In this case, the window length should be
specified as N+2. By default, the filter is scaled so the center of the
first pass band
has magnitude exactly one after windowing. Use a
trailing 'noscale' argument to prevent this scaling, e.g.
B = fir1(N,Wn,'noscale'), B = fir1(N,Wn,'high','noscale'),
B = fir1(N,Wn,wind,'noscale').
You can also specify the scaling
explicitly, e.g. fir1(N,Wn,'scale'), etc.
We can specify windows from the Signal Processing Toolbox, such as

boxcar, hamming, hanning, bartlett, blackman, kaiser or chebwin
w = hamming(n) returns an n-point symmetric Hamming window in

the column vector w. n should be a positive integer.
w = hanning(n) returns an n-point symmetric Hann window in the
column vector w. n must be a positive integer.
w=triang(n) returns an n-point triangular window in the column
vector w. The triangular window is very similar to a Bartlett window.
The Bartlett window always ends with zeros at samples 1 and n, while
the triangular window is nonzero at those points. For n odd, the center
(n-2) points of triang(n-2) are equivalent to bartlett(n).
w = rectwin(n) returns a rectangular window of length n in the
column vector w. This function is provided for completeness. A
rectangular window is equivalent to no window at all.
90
UR11EC098
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.

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.
output is displayed in the Figure Window.
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
h=fir1(N-1,wc/pi,'high',triang(N));
freqz(h);
Source code :3
%windows technique of Hamming using Band pass filter
clc;
clear all;
close all;
wc1=input('Lower Cut off frequency:');
wc2=input('Upper Cut off frequency:');
wc=[wc1 wc2];
h=fir1(N-1,wc/pi,'bandpass',hamming(N));
freqz(h);
Source code :4
%windows technique of Hanning using Band stop filter
clc;
clear all;
close all;
wc1=input('Lower Cut off frequency:');
wc2=input('Upper Cut off frequency:');
wc=[wc1 wc2];
h=fir1(N-1,wc/pi,'stop',hanning(N));
freqz(h);
92
UR11EC098
Source code :5
%windows technique of Blackman window using low pass filter
clc;
clear all;
close all;
h=fir1(N-1,wc/pi,blackman(N));
freqz(h);
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
ENTER THE FILTER

SPECIFICATIONS (PASS,
STOP BAND GAINS AND
EDGE FREQUENCIES)
DESIGN THE ANALOG BUTTERWORTH

AND CHEBYSHEV FILTER
PLOT THE WAVEFORMS
STOP
97
UR11EC098
EX. NO : 9
DATE: 17-02-14
9.DESIGN OF BUTTERWORTH FILTERS
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
where N is the order of the filter and c is the cut-off frequency.

As N , the low pass filter is said to be normalized. All types of
filters namely-Low pass, High pass, Band pass and Band elimination filters
can be derived from the Normalized Low pass filter.
STEPS IN DESIGNING ANALOG FILTER:

1. Transform the given specification to a Normalized Low pass
specification
2. Find the order of the filter N and cut-off frequency c
98
UR11EC098
3. Find the transfer function H(s) of normalized LPF.

4. Use the applicable analog-to-analog transformation to get the transfer
function of the required filter.
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
Bandpass: Wp = [.2 .7], Ws = [.1 .8]

Bandstop: Wp = [.1 .8], Ws = [.2 .7]
buttord: also returns Wn, the Butterworth natural frequency (or) the
"3 dB frequency" to be used with BUTTER to achieve the
specifications.
99
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)
b (1)s nb-1 + b(2)s nb-2 + ... + b(nb)

-------------------------------------------------a(1)s na-1 + a(2)s na-2 + ... + a(na)
given the numerator and denominator coefficients in vectors B and A.

The frequency response is evaluated at the points specified in vector
W (in rad/s). The magnitude and phase can be graphed by calling
freqs(B,A,W) with no output arguments.
tf: Transfer function
SYS = tf(NUM,DEN) creates a continuous-time transfer function
SYS with
numerator(s) NUM and denominator(s) DEN. The output SYS is a tf
object.
100
UR11EC098
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.
Command window.
4. Run the program.
5. Enter the input in the command 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
%Plotting magnitude & phase response

f=linspace(1,512,1000);
h=freqs(b,a,f);
m=20*log(abs(h));
subplot(2,1,1);
semilogx(f,m);
title('Magnitude response of Butterworth LPF');
% Phase response
p=angle(h);
subplot(2,1,2);
semilogx(f,p);
ylabel('Phase');
title('Phase response of Butterworth LPF');
SOURCE CODE:2
clc;
clear all;
close all;
%% Butterworth high pass Filter
k1=input('Enter the passband gain in db:');
k2=input('Enter the stopband gain in db:');
%filter
[n,Wc]=buttord(w1,w2,k1,k2,'s');
disp(n);
disp(Wc);
102
UR11EC098

[b,a]=butter(n,Wc,'high','s');
%Plotting magnitude & phase response
f=linspace(1,512,1000);
h=freqs(b,a,f);
m=20*log(abs(h));
subplot(2,1,1);
semilogx(f,m);
title('Magnitude response of Butterworth HPF');
% Phase response
p=angle(h);
subplot(2,1,2);
semilogx(f,p);
ylabel('Phase');
title('Phase response of Butterworth HPF');
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]=buttord(Wp,Ws,Rp,Rs,'s')
%To find cut off frequency
Wc=[Wp Ws];
103
UR11EC098
%Band pass Filtering

[b,a]=butter(N,Wc,'bandpass','s');
%plotting magnitude and phase response
figure(1);freqs(b,a);
SOURCE CODE:4
clc;
clear all;
close all;
%% Bandstop Filter Specifications
[N]=buttord(Wp,Ws,Rp,Rs,'s')
Wc=[Wp Ws];
%Band stop Filtering
[b,a]=butter(N,Wc,'stop','s');
Command Windows :
Using Low pass filter
104
UR11EC098
Using High pass filter
Using Band pass filter
Using Band stop filter
105
UR11EC098
OUTPUTS:
Using Low pass filter
Using High pass filter
106
UR11EC098
Using Band pass filter
Using Band stop filter
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
ENTER THE FILTER

STOP BAND GAINS AND
EDGE FREQUENCIES)
DESIGN THE ANALOG BUTTERWORTH

AND CHEBYSHEV FILTER
PLOT THE WAVEFORMS
STOP
109
UR11EC098
EX. NO : 10
DATE: 17-02-14
10.DESIGN OF CHEBYSHEV FILTERS
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 )
is the ripple parameter in pass band
CN(x) is the Nth order Chebyshev polynomial defined as

Cos ( N cosh 1 x) ,
CN(x) =
Cos ( N cosh 1 x),
110
x 1
x 1
UR11EC098
STEPS IN DESIGNING ANALOG FILTER:

1.Transform the given specification to a Normalized Low pass
specification
2. Find the order of the filter N and cut-off frequency c
3. Find the transfer function H(s) of normalized LPF.
4. Use the applicable analog-to-analog transformation to get the transfer
function of the required filter.
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
Bandpass: Wp = [.2 .7], Ws = [.1 .8]

Bandstop: Wp = [.1 .8], Ws = [.2 .7]
cheb1ord also returns Wn, the Chebyshev natural frequency to use
with cheby1 to achieve the specifications.
[N, Wn] = cheb1ord (Wp, Ws, Rp, Rs, 's') does the computation for
an analog filter, in which case Wp and Ws are in radians/second.
cheby1 Chebyshev Type I digital and analog filter design.
111
UR11EC098
[B,A] = cheby1 (N,R,Wn) designs an Nth order Low pass digital

Chebyshev filter with R decibels of peak-to-peak ripple in the pass
band. cheby1 returns the filter coefficient vectors B (numerator) and
A (denominator) of length N+1. The cut-off frequency Wn must be in
the range 0.0 < Wn < 1.0, with 1.0 corresponding to half the sample
rate. Use R=0.5 as a starting point, if you are unsure about choosing
R.
cheby1 (N,R,Wn,'s'), cheby1 (N,R,Wn,'low','s'),
cheby1
(N,R,Wn,'high','s'), cheby1 (N,R,Wn,'pass','s')
and
cheby1
(N,R,Wn,'stop','s') design analog Chebyshev Type I filters. In this
case, Wn is in [rad/s] and it can be greater than 1.0.
programs and click on MATLAB) to get into the Command Window.
Command window.
4. Run the program.
CHEBYSHEV FILTERS :
Source code:1
clc;
clear all;
close all;
%% Chebyshev low pass Filter
k1=input('Enter the passband ripple in db:');
112
UR11EC098
k2=input('Enter the stopband attenuation in db:');

%filter
[n,Wc]=cheb1ord(w1,w2,k1,k2,'s');
disp(n);
disp(Wc);
[b,a]=cheby1(n,k1,w1,'low','s');
Source code:2
clc;
clear all;
close all;
%% Chebyshev High pass Filter
k1=input('Enter the passband ripple in db:');
k2=input('Enter the stopband attenuation in db:');
%filter
[n,Wc]=cheb1ord(w1,w2,k1,k2,'s');
disp(n);
disp(Wc);
% High pass filtering
[b,a]=cheby1(n,k1,w1,'high','s');
113
UR11EC098
Source code: 3
clc;
clear all;
close all;
%% Bandpass Filter Specifications
[N]=cheb1ord(Wp,Ws,Rp,Rs,'s')
Wc=[Wp Ws];
%Band pass Filtering
[b,a]=cheby1(N,Rp,Wc,'bandpass','s');
Source code: 4
clc;
clear all;
close all;
%% Bandstop Filter Specifications
[N]=cheb1ord(Wp,Ws,Rp,Rs,'s')
Wc=[Wp Ws];
%Bandstop Filtering
114
UR11EC098
[b,a]=cheby1(N,Rp,Wc,'stop','s');
Command Window :1(LPF)
Output:
115
UR11EC098
Command Window :2(HPF)
Output:
Command Window :3(BPF)
116
UR11EC098
Output:
Command Window :4(BSF)
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
ENTER THE FILTER

STOP BAND GAINS AND
EDGE FREQUENCIES)
DESIGN THE ANALOG BUTTERWORTH AND

CHEBYSHEV LOW PASS FILTER
CONVERT THE LOW PASS FILTERS IN TO
DIGITAL FILTERS BY USING THE IMPULSE
INVARIANT AND BILINEAR
TRANSFORMATIONS
PLOT THE WAVEFORMS
STOP
119
UR11EC098
EX. NO : 11
DATE: 03-03-14
11.DESIGN OF IIR FILTERS
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
This transformation maps the j axis (from = - to +) repeatedly around

the unit circle (exp ( jw), from w=- to ) by
2

tan
T
2
BILINEAR TRANSFORMATION:
DESIGN STEPS:
1. From the given specifications, Find pre-warped analog
frequencies using
2

tan
T
2
2. Using the analog frequencies, find H(s) of the analog filter

3. Substitute S
2 1 Z 1
in the H(s) of Step:2
T 1 Z 1
IMPULSE INVARIANT TRANSFORMATION:

DESIGN STEPS:
1. Find the analog frequency using
= /T
2. Find the transfer function of analog filter Ha(s)
121
UR11EC098
3. Express the analog filter transfer function as a sum of single pole

filters
4. Compute H(Z) of digital filter using the formula
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
1. Calculate the attenuation in dB for the given design parameters

2. Design the analog counterpart
3. Using Impulse Invariant /Bilinear transformation design the digital
filter
4. Display the transfer function. Plot the magnitude response and phase
response
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
');
T=input('Enter the Sampling Frequency in rad/sec: ');

Sp=input('Enter the Pass-band Ripple Gain: ');
Wp=input('Enter the Pass-band Edge Frequency in rad/sec: ');
Ss=input('Enter the Stop-band Ripple Gain: ');
Ws=input('Enter the Stop-band Edge Frequency in rad/sec: ');
% Calculation of ohmp,ohms,Ap,As
Ap=abs(20*log10(1-Sp));
As=abs(20*log10(Ss));
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
[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);
title('Magnitude Response of IIR Filter using Impulse Invariant Method');
% Phase Response
Ha=angle(H);
subplot(2,1,2);
semilogx(O,Ha);
ylabel('Phase');
title('Phase Response of IIR Filter using Impulse Invariant Method');
/ Butterworth Lowpass Bilinear Transformation Method

clc;
clear all;
close all;
warning off;
124
UR11EC098
% T=1,both the ripple gains should have band width( .1 to .3)

disp(' Butterworth Lowpass filter using Bilnear transformation method
');
ohmp=Wp/T;
ohms=Ws/T;
% Butterworth Filter
[n,Wc]=buttord(ohmp,ohms,Ap,As,'s');
[bz,az] = bilinear(b,a,1/T);
tf(bz,az,T);
H=freqz(bz,az,O);
subplot(2,1,1);
semilogx(O,Hm);
title('Magnitude Response of IIR Filter using Bilinear Transformation
Method');
% Phase Response
Ha=angle(H);
subplot(2,1,2);
semilogx(O,Ha);
125
UR11EC098
ylabel('Phase');
title('Phase Response of IIR Filter using Bilinear Transformation Method');
/ Chebyshev Lowpass Impulse invariant method

clc;
clear all;
close all;
warning off;
disp(' Chebyshev Lowpass filter using Impulse invariant method
');

ohmp=Wp/T;
ohms=Ws/T;
% Chebyshev Filter
[n,Wc2]=cheb1ord(ohmp,ohms,Ap,As,'s')
[b,a]=cheby1(n,Ap,Wc2,'low','s');
[bz,az] = impinvar(b,a,T);
tf(bz,az,T);
H=freqz(bz,az,O);
126
UR11EC098
subplot(2,1,1);
semilogx(O,Hm);
title('Magnitude Response of IIR Filter using Impulse Invariant Method');
% Phase Response
Ha=angle(H);
subplot(2,1,2);
semilogx(O,Ha);
ylabel('Phase');
title('Phase Response of IIR Filter using Impulse Invariant Method');
/Chebyshev Lowpass Bilinear Transformation Method

clc;
clear all;
close all;
warning off;
disp(' Chebyshev Lowpass filter using Bilnear transformation method
');
ohmp=Wp/T;
127
UR11EC098
ohms=Ws/T;
% Chebyshev Filter
[n,Wc2]=cheb1ord(ohmp,ohms,Ap,As,'s')
[b,a]=cheby1(n,Ap,Wc2,'low','s');
[bz,az] = bilinear(b,a,1/T);
tf(bz,az,T);
H=freqz(bz,az,O);
subplot(2,1,1);
semilogx(O,Hm);
title('Magnitude Response of IIR Filter using Bilinear Transformation
Method');
% Phase Response
Ha=angle(H);
subplot(2,1,2);
semilogx(O,Ha);
ylabel('Phase');
title('Phase Response of IIR Filter using Bilinear Transformation Method');
128
UR11EC098
/ Butterworth Lowpass Impulse invariant method

Command window:
Output:
129
UR11EC098
/ Butterworth Lowpass Bilinear Transformation Method

Command Window :
Output:
130
UR11EC098
/ Chebyshev Lowpass Impulse invariant method

Command Window:
Output:
131
UR11EC098
/Chebyshev Lowpass Bilinear Transformation Method

Command Window:
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
ENTER THE SYSTEMS

NUMERATOR AND
DENOMINATOR
COEFFICIENTS
GENERATE THE WAVEFORM OF TIME

DOMAIN RESPONSE BY USING THE
APPROPRIATE LIBRARY FUNCTION
PLOT THE WAVEFORMS
STOP
134
UR11EC098
EX. NO :12(A)
DATE:10-03-14
TIME DOMAIN RESPONSE OF LTI SYSTEMS
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]
* is the Convolution operator
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.
Programs and click on MATLAB) to get into the Command Window
Command window.
3. Write the program in the Edit window and save it in M-file
4. Run the program
136
UR11EC098

SOURCE CODE:
PROGRAM 1
clc;
clear all;
close all;
%% Input the samples
% Time domain response of FIR filter
N=16; %Input samples
k=0:N-1;
x=(k==0);
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 Impulse');
title('Impulse input');
subplot(2,2,2), stem(k,y,'r');
title('Impulse Response FIR Filter');
% Time domain Response of IIR Filter
N1=10; %input samples
k1=0:N1-1;
x1=(k1==0);
B1=1;
a=0.8;
A1=[1,-a];
y1=filter(B1, A1 ,x1);
%plot the graph
137
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');
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');
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');
title('Step Response IIR Filter');
Output for Unit impulse input:
139
UR11EC098
Output for Unit step input:
RESULT:
The Time domain responses of the given systems were found using
MATLAB and manually verified.
140
UR11EC098
FLOWCHART:
START
ENTER THE SYSTEMS

NUMERATOR AND
DENOMINATOR
COEFFICIENTS
GENERATE THE WAVEFORM OF

FREQUENCY
PLOT THE WAVEFORMS
STOP
141
UR11EC098
EX. NO : 12(B)
DATE:10-03-14
FREQUENCY DOMAIN RESPONSE OF LTI SYSTEMS
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
y [n]= x(k )h(n k )

k
This is known as convolution sum and can be represented as

y[n]
= x[n]*h[n]
* is the Convolution operator

FREQUENCY RESPONSE:
y[n] can also be written as
y[n]=
h( k ) x ( n k )
If x[n] is a complex exponential of the form x[n] =ejn where n varies from to
Then y[n] = e j ( n k ) h(k )

k
jk
.e jn h(k )
jk
h(k )e jwn
y[n]=H(ej) ejn
where H(ej)= e jk h(k )

k
H(ej) is called the frequency response of DTLTI system. It is a complex

function
H(ej) =Hr(ej )+j Him(ej)
H(ej)= H (e j ) ej()
143
UR11EC098
H (e j ) is the magnitude response. ( ) is the phase response.
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
programs and click on MATLAB) to get into the Command Window
Command window.
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

DIgital Signal Processing Lab Manual

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

DIgital Signal Processing Lab Manual

Uploaded by

Copyright:

Available Formats

FLOWCHART:

GENERATE THE WAVEFORM BY USING

2. Unit step sequence,

2. Unit step signal

3. Unit Ramp sequence,

Unit impulse sequence. x (n) (n)

Unit step sequence. x (n) u(n)

Unit ramp sequence. x (n) r (n)

Sinusoidal sequence. x(n) A sin(n ) .

Exponential sequence. x(n) = A an, where A and a are constant.

Unit impulse signal. x (t ) (t ) 0, otherwise

Unit ramp signal.

Sinusoidal signal. x(t ) A sin t ) .

OUTPUT WAVEFORM(CONTINUOUS TIME):

OUTPUT WAVEFORM (DISCRETE TIME):

READ THE INPUT

PERFORM OPERTAION ON THE D.T. SIGNAL

PLOT THE WAVEFORMS

BASIC OPERATIONS ON D.T SIGNALS

Write a program in MATLAB to study the basic operations on the

Pentium 4 Processor, MATLAB software

Let x(n) be a sequence with finite length.

by multiplying the values y2[n]= x1[n] X x2[n]

y[n]=x[an], where a is a constant.

y[n]=x[n - ], where is a constant.

Time reflection (folding):y[n]=x[-n]

Array multiplication (element-wise)

tic & toc Start a stopwatch timer.

Time shifting of the independent variable :

Addition and multiplication of two signals :

OUTPUT (operations on the amplitude of signal ):

OUTPUT(Time shifting of the independent variable) :

OUTPUT(Addition and multiplication of two signals) :

The program to perform various operations on discrete time signal is

READ THE INPUT

READ THE CONSANT FOR

READ THE (VECTOR)

PERFORM OPERTAION ON THE D.T. SIGNAL USING

PROPERTIES OF DISCRETE TIME SYSTEM

But does not depend on future inputs [x (n+1),x(n+2),..]

- to + is taken and if the sum is finite, the system

is said to be BIBO stable.

C = POWER(A,B) is called for the syntax 'A .^ B' when A or B is an

residuez Z-transform partial-fraction expansion.

zplane Z-plane zero-pole plot.

tf Creation of transfer functions or conversion to transfer function.

x1=input('Enter input sequence x1:');

%Properties of DT Systems(Time Invariance)

Time invariant system :3

Time variant system : 4

ENTER THE SIGNAL

PERFORM THE SAMPLING RATE CONVERSION

PERFORM INTERPOLATION AND DECIMATION

FIND THE SPECTRUM OF

PLOT THE WAVEFORMS

SAMPLING RATE CONVERSION

Write a MATLAB Script to perform sampling rate conversion for any

T period of the train

a sequence with a sampling rate of F Hz and it is used to generate another

UPSAMPLE AND INTERPOLATION:

SAMPLING RATE CONVERSION BY A RATIONAL FACTOR I/O:

Increases sampling rate by an integer factor

upsample: Increases the sampling rate of the input signal