DSP 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
EX.
:1
EX. NO
NO
:1
DATE:09-12-13
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
3. Ramp signal
Impulse
4. Sinusoidal
sequence,
2. Unit
step
sequence,
3. Unit Ramp
sequence,
4. Sinusoidal
signal,
5. Exponential
signal,
6. R
a
n
sequence,
5. Exponential
sequence,
6. Random
sequence,
i
g
1. Pulse signal,
2. Unit
step
signal
APPARATUS REQUIRED:
Pentium 4 Processor, MATLAB software
THEORY:
2
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 ) .
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
0, otherwise
x (t ) u(t )
Unit step signal.

Unit ramp signal.
t , for t 0
0, otherwise
x (t ) r ( t )
Sinusoidal signal.
x(t ) A sin t )
( , where A
Exponential signal.
x (t ) = A e
and a are constant.
at
a
t
LIBRARY FUNCTIONS:
clc:
3
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.
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:
4
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 Mby-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.
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.
5
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');
6
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);
7
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);
8
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:
DISCRETE TIME :
OUTPUT WAVEFORM(CONTINUOUS
TIME):
10
OUTPUT WAVEFORM (DISCRETE TIME):
RESULT:
11
The program to generate various

waveforms is written, executed and the output is
verified.
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
12
EX.
:2
EX. NO
NO
:2
DATE
:21-12-13
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
13
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]
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
14
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
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;
15
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');
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:');
16
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');
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');
17
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);
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;
18
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 :
Time shifting of the independent variable :
Addition and multiplication of two signals :

19
OUTPUT (operations on the amplitude of signal

):
20
OUTPUT(Time
shifting of the independent
variable) :
21
OUTPUT(Addition and multiplication of two

signals) :
RESULT:
22
The program to perform various operations

on discrete time signal is written, executed and the
output is verified
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
23
EX.
::
EX. NO
NO
33
DATE:
DATE: 06-1-14
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 [a1 x1 (n) a 2 x 2 (n)] a1T [ x1 ( n)] a 2T [ x 2 ( n)]
METHODS OF PROOF:
Individual inputs are applied and the
weighted sum of the outputs is taken. Then the
24
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(n1).y(n-1),..]
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 noncausal.
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.
25
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.
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.
26
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 discretetime 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.
27
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
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):');
28
is
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;
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)
29
%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):');
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');
30
Source code :3
clc;
clear all;
close all;
%Properties of DT Systems(Time Invariance)
%y(n)=x(n);
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');
31
Source code :4
clc;
clear all;
close all;
%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');
32
title('L.H.S');
subplot(2,2,4);
stem(y3);
xlabel('time');
title('R.H.S');
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);
33
figure
zplane(nr,dr);
if abs(p)<1
disp('the system is stable');
else
disp('the system is unstable');
end;
Non-Linear System :1
Output :
34
Linear System :2
Output :
35
Time invariant system :3
Output :
36
Time variant system : 4
Output :
37
Non-Causal system :5
Unstable system :6
Output :
38
39
RESULT:
The properties of Discrete Time system is
verified using MATLAB
FLOWCHART:
40
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
EX.
::
EX. NO
NO
44
DATE:
DATE: 13-1-14
13-1-14
SAMPLING RATE CONVERSION

41
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),
42
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 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 M1 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

43
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
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 antiimaging filter.
The input sequence is passed
through an anti-imaging filter after up sampling.

x[n]
y[n]
ANTI IMAGING
FILTER H (Z)
SAMPLING RATE CONVERSION BY A

RATIONAL FACTOR I/O:
44
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
y[n]
FILTER
ANTI
ALIASING
FILTER
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.
45
DOWN
SAMPLER
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 ,
46
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
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
47
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
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');
48
Output :
49
50
RESULT:
The program written using library functions
and the sampling rate conversion process is
studied.
51
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
52
EX.
::
EX. NO
NO
55
DATE
DATE :: 20-1-14
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.
53
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]
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 n0 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
y[n] = x1[n] * x2[n] =
x2 (k) or
N 1
x
k 0
N 1
x
k 0
[(n-k) mod N]
( k ) x2 [(n-k) mod N]
54
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.
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
convolving
them
multiplying
the
coefficients,
is
equivalent
to
two
polynomials
in
frequency domain.
length: Length of vector.
55
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 ND arrays, the fft operation operates on the
first non-single dimension. fft(x,N) is the Npoint 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
56
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
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');
57
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);
disp('The Linear convoluted sequence is');
disp(f);
subplot(3,1,3);
stem(f);
xlabel('Time');
title('Linear Convoluted sequence');
Command window :
OUTPUT :
58
SOURCE CODE :2
clc;
clear all;
close all;
%Program to perform Circular Convolution
convoluted:');
subplot(3,1,1);
l1=length(x1);
stem(x1);
xlabel('Time');
convoluted:');
subplot(3,1,2);
l2=length(x2);
stem(x2);
59
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');
Command window :
OUTPUT :
60
SOURCE CODE :3
clc;
clear all;
close all;
%Program to perform Linear Convolution using
Circular Convolution
convoluted:');
subplot(3,1,1);
l1=length(x1);
stem(x1);
xlabel('Time');
61

convoluted:');
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');
Command window :
62
OUTPUT:
SOURCE CODE :4
clc;
63
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');
X=fft(x,length(y));
64
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');
65
Command window :
OUTPUT :
66
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)
67
j=n+j;
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 :
68
69
RESULT:
The linear and circular convolutions are
performed by using MATLAB script and the
program results are verified by manual calculation.
FLOWCHART:
70
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
71
EX.
::
EX. NO
NO
66
DATE
DATE :: 27-127-114
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 Z-transform 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.
72
It finds its application in Digital Signal

processing including Linear filtering, Correlation
analysis and Spectrum analysis.
Consider a complex series x [n] with N samples of
the form
complex
Where x is a
number
Further,
assume that the series outside the range 0, N-1 is

extended N-periodic, 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 n 0
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.
73
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.
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
non-singleton
dimension.
(or go to Start - All Programs and click on
MATLAB) to get into the Command
Window
74

save it as m-file
4. Run the program
window
and
the
graphical
output
is

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
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
75
%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);
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);
76
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);
title ('FFT of input sequence');
Command Window :
77
OUTPUT :
78
RESULT:
The program for DFT calculation was
performed with library functions and without
library functions. The results were verified by
manual calculation.
79
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
80
EX.
EX. NO
NO
:7
:7
DATE
DATE :3-2-14
:3-2-14
FAST
FAST FOURIER TRANSFORM
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
X (k) =
N 1
x(n)e j 2nk/N
n 0
k=0,
1.N-1
which may conveniently be written in the
form
N 1
X (k) =
n 0
nk
x ( n) w N
k=0,
1.N-1
81
where WN=e-j2/N which is known as

Twiddle or Phase factor.
COMPUTATION OF DFT:
To compute DFT, it requires N 2
multiplication and (N-1) N complex addition.
Direct computation of DFT is basically inefficient
precisely 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
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 ,
x [n] =
1 N 1
X(k )WN nk
N n0
82
where, wN=e-j2/N.
Taking conjugate and multiplying by N, we get,
N 1
N x*[n] =
k 0
X* (k )WNnk
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,
x [n]=
1 N 1 *
[ X (k ) W Nnk ]*
N k 0
RADIX-2 DECIMATION IN TIME FFT:

The idea is to successively split the Npoint 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
83
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:
Decimation
in
t i me
( D I T ) fft
ditfft(x) is the discrete Fourier transform (DFT)
of vector x in time domain decimation
diffft:
D e c i ma t i o n i n f r e q u e n c y
( D I F ) fft
84
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:');
85
im(i)= input('Enter the imaginary part of the

element:');
end
%% Call Dit_fft function
[re1,im1]= ditfft(re,im,N);
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);
86
disp(im1);
%figure(2)
subplot(2,2,3);
stem(re1);
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;
87
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
Function Table:(DITIFFT)
function [ re,im] = ditifft(re,im,N)
here
N1=N-1;
N2=N/2;
j=N2+1;
M=log2(N);
%Bit reversal sorting
88
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;
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
89
end
end
Command Window:
Output:
90
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);
91
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
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);
92
xlabel('Time');
Function Table:(DIFFFT)
function [re, im ] = diffft(re, im, N)
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)=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;
93
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
Function Table:(DIFIFFT)
function [ re, im ] = dififft( re, im, N)
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);
94
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
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:
95
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
E
n
t
e
r
t
h
e
i
m
a
g
i
n
a
r
96
y
p
a
rt
o
f
t
h
e
e
l
e
m
e
n
t:
0
r
e
97
1
=
4
im1 =
0
Enter the number of points in DIF IFFT:4

re
1
=
1
im1 =
0
Output:
98
99
RESULT:
The DFT and IDFT of the given sequence
are computed using FFT algorithm both DITFFT
and DIFFFT.
FLOWCHART:
100
START
ENTER THE FILTER

SPECIFICATIONS (ORDER OF
THE FILTER, CUT-OFF
FREQUENCY)
DESIGN THE FILTER
PLOT THE WAVEFORMS
STOP
101
EX.
EX. NO
NO
:8
:8
DATE
DATE :10-2-14
: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:
102
Fourier series method

Frequency sampling method
Window method
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.
103
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 Norder 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.
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.
104
fir1(N,Wn,'noscale'),
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
hamming,
Toolbox,
hanning,
such
as
bartlett,
boxcar,
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).
105
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.
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.

save it in M-file.
4. Run the program.
5. Enter the input in the Command Window.
window
and
the
graphical
output
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:');
106
is
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;
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);
107
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);
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
108
Output:1
Command Window :2
OUTPUT: 2
109
Command Window :3
Output:3
110
Command Window :4
Output:4
Command Window :5
111
Output:
RESULT:
The given low pass filter was designed using
Window method and manually verified filter coefficient of the filters.
112
FLOWCHART:
START
ENTER THE FILTER

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

AND CHEBYSHEV FILTER
PLOT THE WAVEFORMS
STOP
113
EX.
::
EX. NO
NO
99
DATE:
DATE: 17-0217-0214
14
9.DESIGN
9.DESIGN OF
OF BUTTERWORTH
BUTTERWORTH FILTERS
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
1
H ( j ) 2
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:
114
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:
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.
115
[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.
[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.
116
H = freqs(B,A,W) returns the complex

frequency response vector H of the filter
B/A:
B(s)
+ ... + b(nb)
b (1)s nb-1
+ b(2)s nb-
H(s) = ---=
-------------------------------------------------A(s)
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 continuoustime transfer function SYS with

numerator(s) NUM and denominator(s)
DEN. The output SYS is a tf object.
(or go to Start All programs and click on
117

Window.
save it in M-file.
4. Run the program.
5. Enter the input in the command window.
window
and
the
graphical
output
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:');
118
is
disp(Wc);
% Low pass filtering
[b,a]=butter(n,Wc,'low','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 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:');
rad/Sec:');
rad/Sec:');
119

%filter
[n,Wc]=buttord(w1,w2,k1,k2,'s');
disp(n);
disp(Wc);
[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 : ');
120
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 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
121
Using High pass filter
Using Band pass filter
Using Band stop filter
122
OUTPUTS:
Using Low pass filter
Using High pass filter
123
Using Band pass filter
124
Using Band stop filter
125
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.
FLOWCHART:
126
START
ENTER THE FILTER

STOP BAND GAINS AND
EDGE FREQUENCIES)
DESIGN THE ANALOG BUTTERWORTH

AND CHEBYSHEV FILTER
PLOT THE WAVEFORMS
STOP
127
EX.
::
EX. NO
NO
10
10
DATE:
DATE: 17-0217-0214
14
10.DESIGN
10.DESIGN OF
OF CHEBYSHEV
CHEBYSHEV FILTERS
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 equiripple behavior in stop band. The zero lies on the
imaginary axis.
The magnitude-squared function is given as
H ( j )
1
1
2
CN
( / p )
is the ripple parameter in pass band

CN(x) is the Nth order Chebyshev polynomial
defined as
128
CN(x)
Cos( N cosh 1 x) ,
x 1
Cos( N cosh 1 x),
x 1
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
129
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.
[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
130
Type I filters. In this case, Wn is in [rad/s]

and it can be greater than 1.0.
Window.
save it in M-file.
4. Run the program.
window
and
the
graphical
output
is

CHEBYSHEV FILTERS
:
Source code:1
clc;
clear all;
close all;
%% Chebyshev low pass Filter
k1=input('Enter the passband ripple in db:');
k2=input('Enter the stopband attenuation in db:');
rad/Sec:');
131

rad/Sec:');
%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:');
rad/Sec:');
rad/Sec:');
%filter
[n,Wc]=cheb1ord(w1,w2,k1,k2,'s');
disp(n);
disp(Wc);
% High pass filtering
132
[b,a]=cheby1(n,k1,w1,'high','s');
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')
133
Wc=[Wp Ws];
%Bandstop Filtering
[b,a]=cheby1(N,Rp,Wc,'stop','s');
Command Window :1(LPF)
Output:
134
Command Window :2(HPF)
Output:
135
Command Window :3(BPF)
Output:
136
Command Window :4(BSF)
Output:
137
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.
138
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
139
EX.
::
EX. NO
NO
11
11
DATE:
DATE: 03-0303-0314
14
11.DESIGN OF IIR FILTERS

AIM:
Write
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
140
M 1
bk Z k
K 0
N 1
H (Z )
a jZ j
j 1
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
141
3. Substitute
2 1 Z 1
T 1 Z 1
in the H(s)
of Step:2
IMPULSE
INVARIANT
TRANSFORMATION:
DESIGN STEPS:
1. Find the analog frequency using =
/T
2. Find the transfer function of analog filter

Ha(s)
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
142
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
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
143
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));
ohmp=Wp/T;
ohms=Ws/T;
% Butterworth Filter
144
% 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;
145
% T=1,both the ripple gains should have band
width( .1 to .3)
disp(' Butterworth Lowpass filter using Bilnear
transformation method
');
');
rad/sec: ');
rad/sec: ');
ohmp=Wp/T;
ohms=Ws/T;
% Butterworth Filter
above filter specs.
[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);
146

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');
/ Chebyshev Lowpass Impulse invariant
method
clc;
clear all;
close all;
warning off;
disp(' Chebyshev Lowpass filter using Impulse
invariant method
');
');
rad/sec: ');
rad/sec: ');
ohmp=Wp/T;
147
ohms=Ws/T;
% Chebyshev Filter
above filter specs.
[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);
subplot(2,1,1);
semilogx(O,Hm);
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
clc;
clear all;
close all;
warning off;
148

disp(' Chebyshev Lowpass filter using Bilnear
transformation method
');
');
rad/sec: ');
rad/sec: ');
ohmp=Wp/T;
ohms=Ws/T;
% Chebyshev Filter
above filter specs.
[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);
149

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');
/ Butterworth Lowpass Impulse

invariant method
Command window:
Output:
150
/ Butterworth Lowpass Bilinear

Command Window :
151
Output:
/ Chebyshev Lowpass Impulse invariant

method
Command Window:
152
Output:
/Chebyshev Lowpass Bilinear

153
Command Window:
Output:
154
RESULT:
Butterworth and Chebyshev Lowpass filters
were
designed
using
Bilinear
and Impulse
Invariant transformations, and manually verified
155
the order, cut off frequency and filter co-efficient

of the filters.
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
156
EX.
EX. NO
NO
::12(A)
12(A)
DATE:10-03-14
DATE:10-03-14
TIME DOMAIN
DOMAIN RESPONSE OF
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:
T
157
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,
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
and
denominator coefficient vector a. If a(1) is

158
not equal to 1, filter normalizes the filter

coefficients by a(1). If a(1) equals 0, filter
returns an error.
(or go to Start All Programs and click on
Window
save it in M-file
4. Run the program
window
and
the
graphical

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;
159
output
is
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
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;
160
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;
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:
161
Output for Unit step input:
162
RESULT:
163
The Time domain responses of the given

systems were found using MATLAB and manually
verified.
FLOWCHART:
START
ENTER THE SYSTEMS

NUMERATOR AND
DENOMINATOR
COEFFICIENTS
GENERATE THE WAVEFORM OF

FREQUENCY
PLOT THE WAVEFORMS
STOP
164
EX.
::
EX. NO
NO
12(B)
12(B)
DATE:10-03-14
DATE:10-03-14
FREQUENCY
FREQUENCY DOMAIN
DOMAIN RESPONSE
RESPONSE OF
OF LTI
LTI SYSTEMS
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]]
165
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 ) ]
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[[nk]] = 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 )
k
If x[n] is a complex exponential of the form x[n]

=ejn where n varies from - to
j ( n k )
h( k )
Then y[n] = e
k
j k
.e jn h( k )
= e
k
j k
h( k )e jwn
= e
k
166
y[n]=H(ej) ejn
jk
h(k )
where H(ej)= e
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 )
H ( e j )
ej()
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 discretetime filters, freqz returns the matrix h. Each
column of h corresponds to one filter in the
vector hd.
Angle: Phase angle
167
P = angle (Z) returns the phase angle, in

radians, for each element of complex array
Z.
log10:
The log10 function operates element-byelement on arrays. Its domain includes
complex numbers, which may lead to
unexpected results if used unintentionally
Window
save it in M-file.
4. Run the program.
window
and
the
graphical

SOURCE CODE:
clc;
clear all;
close all;
%Frequency Response
168
output
is
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:
OUTPUT :
169
RESULT:
The frequency response (magnitude and
phase response) of the given system was found
using MATLAB.
170
171

DSP Lab Manual

Încărcat de

Informații document

Descriere originală:

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

DSP Lab Manual

Încărcat de

Drepturi de autor:

Formate disponibile

FLOWCHART:

Real signals can be quite complicated. The study

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

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

Unit step signal.

and a are constant.

CLC Clear command window.

The rand function generates arrays of

STEM(X,Y) plots the data sequence Y at the

OUTPUT WAVEFORM (DISCRETE TIME):

The program to generate various

READ THE INPUT

BASIC OPERATIONS ON D.T SIGNALS

Write a program in MATLAB to study the

Pentium 4 Processor, MATLAB software

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

Offset the signal: y[n] =a+x[n], where a is

by multiplying the values

y2[n]= x1[n] X x2[n] at each corresponding

Array multiplication (element-wise)

TIC, operation, TOC

Time shifting of the independent variable :

Addition and multiplication of two signals :

OUTPUT (operations on the amplitude of signal

shifting of the independent

OUTPUT(Addition and multiplication of two

The program to perform various operations

READ THE INPUT

PROPERTIES OF DISCRETE TIME SYSTEM

weighted sum of signals input is applied to the

must have the same

dimensions unless one is a scalar. A scalar

C = POWER(A,B) is called for the syntax

conversion to transfer function.

Short-cut for constructing symbolic

Symbolic substitution. subs(S,NEW)

replaces the free symbolic variable in S with

displayed in the Figure Window

Time invariant system :3

Time variant system : 4

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

resampling (i.e. fractional value)

or the frequency equal to twice the highest

sampling rate F Hz, then the

sampling rate alteration is given by,

aliasing, the bandwidth of x[n] must be reduced to

Fmax =Fx/2 or max = /M. The input sequence is

UPSAMPLE AND INTERPOLATION:

according to the relation

The sampling rate of y[n] is L times that of x[n].

The input sequence is passed

through an anti-imaging filter after up sampling.

SAMPLING RATE CONVERSION BY A