Vous êtes sur la page 1sur 171

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.
: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

signal,

step

5. Exponential

sequence,

signal,

3. Unit Ramp

6. R

sequence,

4. Sinusoidal

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

UR11EC098

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

at

a
t

and a are constant.


LIBRARY FUNCTIONS:
clc:
3

UR11EC098

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

UR11EC098

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

UR11EC098

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

UR11EC098

ylabel('Amplitude');
title('Unit impulse signal');
%UNIT STEP SIGNAL
t2=-5:1:25;
x2=[zeros(1,5),ones(1,26)];
subplot(2,3,2);
plot(t2,x2);
xlabel('time');
ylabel('Amplitude');
title('Unit step signal');
%EXPONENTIAL SIGNAL
a=input('Enter the value of a:');
t3=-10:1:20;
x3=exp(-1*a*t3);
subplot(2,3,3);
plot(t3,x3);
xlabel('time');
ylabel('Amplitude');
title('Exponential signal');
%UNIT RAMP SIGNAL
t4=-10:1:20;
x4=t4;
subplot(2,3,4);
plot(t4,x4);
xlabel('time');
ylabel('Amplitude');
title('Unit ramp signal');
%SINUSOIDAL SIGNAL
A=input('Enter the amplitude:');
f=input('Enter the frequency:');
t5=-10:1:20;
x5=A*sin(2*pi*f*t5);
subplot(2,3,5);
plot(t5,x5)
xlabel('time');
ylabel('Amplitude');
title('Sinusoidal signal');
%RANDOM SIGNAL
t6=-10:1:20;
x6=rand(1,31);
7

UR11EC098

subplot(2,3,6);
plot(t6,x6);
xlabel('time');
ylabel('Amplitude');
title('Random signal');
%WAVE FORM GENERATION
%DT SIGNAL
%UNIT IMPULSE
clc;
clear all;
close all;
n1=-3:1:3;
x1=[0,0,0,1,0,0,0];
subplot(2,3,1);
stem(n1,x1);
xlabel('time');
ylabel('Amplitude');
title('Unit impulse signal');
%UNIT STEP SIGNAL
n2=-5:1:25;
x2=[zeros(1,5),ones(1,26)];
subplot(2,3,2);
stem(n2,x2);
xlabel('time');
ylabel('Amplitude');
title('Unit step signal');
%EXPONENTIAL SIGNAL
a=input('Enter the value of a:');
n3=-10:1:20;
x3=power(a,n3);
subplot(2,3,3);
stem(n3,x3);
xlabel('time');
ylabel('Amplitude');
title('Exponential signal');
%UNIT RAMP SIGNAL
n4=-10:1:20;
x4=n4;
subplot(2,3,4);
8

UR11EC098

stem(n4,x4);
xlabel('time');
ylabel('Amplitude');
title('Unit ramp signal');
%SINUSOIDAL SIGNAL
A=input('Enter the amplitude:');
f=input('Enter the frequency:');
n5=-10:1:20;
x5=A*sin(2*pi*f*n5);
subplot(2,3,5);
stem(n5,x5);
xlabel('time');
ylabel('Amplitude');
title('Sinusoidal signal');
%RANDOM SIGNAL
n6=-10:1:20;
x6=rand(1,31);
subplot(2,3,6);
stem(n6,x6);
xlabel('time');
ylabel('Amplitude');
title('Random signal');
CONTINUOUS TIME:

UR11EC098

DISCRETE TIME :

OUTPUT WAVEFORM(CONTINUOUS
TIME):

10

UR11EC098

OUTPUT WAVEFORM (DISCRETE TIME):

RESULT:

11

UR11EC098

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

UR11EC098

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:

Pentium 4 Processor, MATLAB software


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

UR11EC098

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

UR11EC098

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.
ALGORITHM/PROCEDURE:
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

UR11EC098

y3=c*x;
n=length(x);
subplot(2,2,1);
stem(0:n-1,x);
xlabel('time');
ylabel('amplitude');
title('Input signal');
subplot(2,2,2);
stem(0:n-1,y1);
xlabel('time');
ylabel('Amplitude');
title('Amplified signal');
subplot(2,2,3);
stem(0:n-1,y2);
xlabel('time');
ylabel('Amplitude');
title('Attenuated signal');
subplot(2,2,4);
stem(0:n-1,y3);
xlabel('time');
ylabel('Amplitude');
title('Amplitude reversal signal');
%scalar addition
d=input('Input the scalar to be added:');
y4=d+x;
figure(2);
stem(0:n-1,y4);
xlabel('time');
ylabel('Amplitude');
title('Scalar addition signal');
clc;
clear all;
close all;
%Operations on the independent variable
%Time shifting of the independent variable
x=input('Enter the input sequence:');
n0=input('Enter the +ve shift:');
n1=input('Enter the -ve shift:');
16

UR11EC098

l=length(x);
subplot(2,2,1);
stem(0:l-1,x);
xlabel('time');
ylabel('Amplitude');
title('Input signal');
i=n0:l+n0-1;
j=n1:l+n1-1;
subplot(2,2,2);
stem(i,x);
xlabel('time');
ylabel('Amplitude');
title('Positive shifted signal');
subplot(2,2,3);
stem(j,x);
xlabel('time');
ylabel('Amnplitude');
title('Negative shifted signal');
%Time reversal
subplot(2,2,4);
stem(-1*(0:l-1),x);
xlabel('time');
ylabel('Amplitude');
title('Time reversal signal');

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

UR11EC098

ylabel('Amplitude');
title('Input sequence 1');
subplot(2,2,2);
stem(0:l2-1,x2);
xlabel('time');
ylabel('Amplitude');
title('Input sequence 2');
if l1>l2
l3=l1-l2;
x2=[x2,zeros(1,l3)];
y1=x1+x2;
subplot(2,2,3);
stem(0:l1-1,y1);
xlabel('time');
ylabel('Amplitude');
title('Addition of two signals');
y2=x1.*x2;
subplot(2,2,4);
stem(0:l1-1,y2);
xlabel('time');
ylabel('Amplitude');
title('Multiplication of two signals');
end
if l2>l1
l3=l2-l1;
x1=[x1,zeros(1,l3)];
y1=x1+x2;
subplot(2,2,3);
stem(0:l2-1,y1);
xlabel('time');
ylabel('Amplitude');
title('Addition of two signals');
y2=x1.*x2;
subplot(2,2,4);
stem(0:l2-1,y2);
xlabel('time');
ylabel('Amplitude');
title('Multiplication of two signals');
else
y1=x1+x2;
18

UR11EC098

subplot(2,2,3);
stem(0:l1-1,y1);
xlabel('time');
ylabel('Amplitude');
title('Addition of two signals');
y2=x1.*x2;
subplot(2,2,4);
stem(0:l1-1,y2);
xlabel('time');
ylabel('Amplitude');
title('Multiplication of two signals');
end
operations on the amplitude of signal :

Time shifting of the independent variable :

Addition and multiplication of two signals :


19

UR11EC098

OUTPUT (operations on the amplitude of signal


):

20

UR11EC098

OUTPUT(Time

shifting of the independent

variable) :

21

UR11EC098

OUTPUT(Addition and multiplication of two


signals) :

RESULT:

22

UR11EC098

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

UR11EC098

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:
Pentium 4 Processor, MATLAB software
THEORY:
LINEARITY:
The response of the system to a weighted
sum of signals is equal to the corresponding
weighted sum of the responses (outputs) of the
system to each of the individual input signals.
T [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

UR11EC098

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

UR11EC098

STABILITY:
An arbitrary relaxed system is said to be
bounded input bounded output (BIBO) stable, if
and only if every bounded input produces a
bounded output.
METHODS OF PROOF:
1. If the impulse response is given, then the
summation of responses for n ranging from
- 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

UR11EC098

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

UR11EC098

ALGORITHM/PROCEDURE:
1. Click on the MATLAB icon on the desktop
(or go to start all programs and click
on MATLAB) to get into the Command
Window
2. Type edit in the MATLAB prompt >>
that appears in the Command window.
3. Write the program in the Edit window and
save it in M-file
4. Run the program
5. Enter the input in the command window
6. The result is displayed in the Command
window

and

the

graphical

output

is

displayed in the Figure Window


Source code :1
clc;
clear all;
close all;
%Properties of DT Systems(Linearity)
%y(n)=[x(n)]^2+B;
x1=input('Enter first input sequence:');
n=length(x1);
x2=input('Enter second input sequence:');
a=input('Enter scaling constant(a):');
b=input('Enter scaling constant(b):');
B=input('Enter scaling constant(B):');
28

UR11EC098

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');
ylabel('Amplitude');
title('First input sequence');
subplot(2,2,2);
stem(0:n-1,x2);
xlabel('Time');
ylabel('Amplitude');
title('Second input sequence');
subplot(2,2,3);
stem(0:n-1,lhs);
xlabel('Time');
ylabel('Amplitude');
title('LHS');
subplot(2,2,4);
stem(0:n-1,rhs);
xlabel('Time');
ylabel('Amplitude');
title('RHS');
if(lhs==rhs)
display('system is linear');
else
display('system is non-linear');
end;
Source code :2
clc;
clear all;
close all;
%Properties of DT Systems(Linearity)
29

UR11EC098

%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');
ylabel('Amplitude');
title('First signal');
subplot(2,2,2);
stem(x2);
xlabel('time');
ylabel('Amplitude');
title('Second signal');
y1=x1;
y2=x2;
rhs=a*y1+b*y2;
x3=a*x1+b*x2;
lhs=x3;
if(lhs==rhs)
display('system is linear');
else
display('system is non-linear');
end;
subplot(2,2,3);
stem(lhs);
xlabel('time');
ylabel('Amplitude');
title('L.H.S');
subplot(2,2,4);
stem(rhs);
xlabel('time');
ylabel('Amplitude');
title('R.H.S');
30

UR11EC098

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');
ylabel('Amplitude');
title('Input signal');
subplot(2,2,2);
stem(x2);
xlabel('time');
ylabel('Amplitude');
title('Signal after shift');
subplot(2,2,3);
stem(y2);
xlabel('time');
ylabel('Amplitude');
title('L.H.S');
subplot(2,2,4);
stem(y3);
xlabel('time');
ylabel('Amplitude');
title('R.H.S');
31

UR11EC098

Source code :4
clc;
clear all;
close all;
%Properties of DT Systems(Time Invariance)
%y(n)=n*[x(n)];
x1=input('Enter input sequence x1:');
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');
ylabel('Amplitude');
title('Input signal');
subplot(2,2,2);
stem(x2);
xlabel('time');
ylabel('Amplitude');
title('Signal after shift');
subplot(2,2,3);
stem(y2);
xlabel('time');
32

UR11EC098

ylabel('Amplitude');
title('L.H.S');
subplot(2,2,4);
stem(y3);
xlabel('time');
ylabel('Amplitude');
title('R.H.S');
Source code :5
clc;
clear all;
close all;
%Properties of DT Systems(Causality)
%y(n)=x(-n);
x1=input('Enter input sequence x1:');
n1=input('Enter lower limit n1:');
n2=input('Enter lower limit n2:');
flag=0;
for n=n1:n2
arg=-n;
if arg>n;
flag=1;
end;
end;
if(flag==1)
display('system is causal');
else
display('system is non-causal');
end;
Source code :6
disp('stability');
nr=input('input the numerator coefficients:');
dr=input('input the denominator coefficients:');
z=tf(nr,dr,1);
[r,p,k]=residuez(nr,dr);
33

UR11EC098

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

UR11EC098

Linear System :2

Output :

35

UR11EC098

Time invariant system :3

Output :

36

UR11EC098

Time variant system : 4

Output :

37

UR11EC098

Non-Causal system :5

Unstable system :6

Output :

38

UR11EC098

39

UR11EC098

RESULT:
The properties of Discrete Time system is
verified using MATLAB
FLOWCHART:

40

UR11EC098

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

UR11EC098

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

UR11EC098

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

UR11EC098

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


n = 0, 1, 2 .

x[n/L],
y[n] =

0,

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

UR11EC098

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

DOWN
SAMPLER

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

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
ALGORITHM/PROCEDURE:
1. Generate a sinusoidal waveform
2. Using the appropriate library function for
interpolation ,decimation ,upsampling ,
46

UR11EC098

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');
ylabel('Amplitude');
title('Sinusoidal signal');
%decimating the signal
d=input('Enter the value by which the signal is to
be decimated:');
y1=decimate(x,d);
subplot(2,3,2);
stem(y1);
xlabel('time');
ylabel('Amplitude');
title('Decimated signal');
%interpolating the signal
47

UR11EC098

i=input('Enter the value by which the signal is to


be interpolated:');
y2=interp(x,i);
subplot(2,3,3);
stem(y2);
xlabel('time');
ylabel('Amplitude');
title('Interpolated signal');
%resampling the signal
y3=resample(x,3,2);
subplot(2,3,4);
stem(y3);
xlabel('time');
ylabel('Amplitude');
title('Resampled signal');
%downsampling the signal
y4=downsample(x,2);
subplot(2,3,5);
stem(y4);
xlabel('time');
ylabel('Amplitude');
title('Downsampled signal');
%upsampling the signal
y5=upsample(x,3);
subplot(2,3,6);
stem(y5);
xlabel('time');
ylabel('Amplitude');
title('Upsampled signal');

48

UR11EC098

Output :

49

UR11EC098

50

UR11EC098

RESULT:
The program written using library functions
and the sampling rate conversion process is
studied.
51

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

52

UR11EC098

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
UR11EC098

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

UR11EC098

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

UR11EC098

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.

ALGORITHM/PROCEDURE:
LINEAR CONVOLUTION:
1. Enter the sequences (Input x[n] and the
Impulse response h[n])
2. Perform the linear convolution between x[k]
and h[k] and obtain y[n].
3. Find the FFT of x[n] & h[n].Obtain X and H
56

UR11EC098

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');
ylabel('Amplitude');
57

UR11EC098

title('First sequence');
x2=input('Enter the second sequence to be
convoluted:');
subplot(3,1,2);
stem(x2);
xlabel('Time');
ylabel('Amplitude');
title('Second sequence');
f=conv(x1,x2);
disp('The Linear convoluted sequence is');
disp(f);
subplot(3,1,3);
stem(f);
xlabel('Time');
ylabel('Amplitude');
title('Linear Convoluted sequence');
Command window :

OUTPUT :

58

UR11EC098

SOURCE CODE :2
clc;
clear all;
close all;
%Program to perform Circular Convolution
x1=input('Enter the first sequence to be
convoluted:');
subplot(3,1,1);
l1=length(x1);
stem(x1);
xlabel('Time');
ylabel('Amplitude');
title('First sequence');
x2=input('Enter the second sequence to be
convoluted:');
subplot(3,1,2);
l2=length(x2);
stem(x2);
59

UR11EC098

xlabel('Time');
ylabel('Amplitude');
title('Second sequence');
if l1>l2
l3=l1-l2;
x2=[x2,zeros(1,l3)];
elseif l2>l1
l3=l2-l1;
x1=[x1,zeros(1,l3)];
end
f=cconv(x1,x2);
disp('The Circular convoluted sequence is');
disp(f);
subplot(3,1,3);
stem(f);
xlabel('Time');
ylabel('Amplitude');
title('Circular Convoluted sequence');
Command window :

OUTPUT :

60

UR11EC098

SOURCE CODE :3
clc;
clear all;
close all;
%Program to perform Linear Convolution using
Circular Convolution
x1=input('Enter the first sequence to be
convoluted:');
subplot(3,1,1);
l1=length(x1);
stem(x1);
xlabel('Time');
ylabel('Amplitude');
title('First sequence');
61

UR11EC098

x2=input('Enter the second sequence to be


convoluted:');
subplot(3,1,2);
l2=length(x2);
stem(x2);
xlabel('Time');
ylabel('Amplitude');
title('Second sequence');
if l1>l2
l3=l1-l2;
x2=[x2,zeros(1,l3)];
elseif l2>l1
l3=l2-l1;
x1=[x1,zeros(1,l3)];
end
n=l1+l2-1;
f=cconv(x1,x2,n);
disp('The convoluted sequence is');
disp(f);
subplot(3,1,3);
stem(f);
xlabel('Time');
ylabel('Amplitude');
title('Convoluted sequence');
Command window :

62

UR11EC098

OUTPUT:

SOURCE CODE :4
clc;
63

UR11EC098

clear all;
close all;
%Program to perform Linear Convolution
x=input('Enter the first input sequence:');
l1=length(x);
subplot(3,2,1);
stem(x);
xlabel('Time index n---->');
ylabel('Amplitude');
title('input sequence');
h=input('Enter the system response sequence:');
l2=length(h);
subplot(3,2,2);
stem(h);
xlabel('Time index n---->');
ylabel('Amplitude');
title('system response sequence');
if l1>l2
l3=l1-l2;
h=[h,zeros(1,l3)];
elseif l2>l1
l3=l2-l1;
x=[x,zeros(1,l3)];
end
y=conv(x,h);
disp('The time domain convoluted sequence is:');
disp(y);
subplot(3,2,3);
stem(y);
xlabel('Time index n---->');
ylabel('Amplitude');
title('convoluted output sequence');

X=fft(x,length(y));
64

UR11EC098

H=fft(h,length(y));
Y=X.*H;
disp('The frequency domain multiplied sequence
is:');
disp(Y);
subplot(3,2,4);
stem(Y);
xlabel('Time index n---->');
ylabel('Amplitude');
title('frequency domain multiplied response');
y1=ifft(Y,length(Y));
disp('The inverse fourier transformed sequence
is:');
disp(y1);
subplot(3,2,5);
stem(y1);
xlabel('Time index n---->');
ylabel('Amplitude');
title('output after inverse fourier transform');
e=y-y1;
disp('The Error sequence:')
disp(abs(e));
subplot(3,2,6);
stem(abs(e));
xlabel('Time index n---->');
ylabel('Amplitude');
title('error sequence');

65

UR11EC098

Command window :

OUTPUT :

66

UR11EC098

SOURCE CODE :5
clc;
clear all;
close all;
%PROGRAM FOR CIRCULAR
CONVOLUTION USING DISCRETE
CONVOLUTION EXPRESSION
x=input('Enter the first sequence:');
n1=length(x);
h=input('Enter the second sequence:');
n2=length(h);
n=0:1:n1-1;
subplot(3,1,1);
stem(n,x);
xlabel('Time');
ylabel('Amplitude');
title('First sequence Response x(n)');
n=0:1:n2-1;
subplot(3,1,2);
stem(n,h);
xlabel('Time');
ylabel('Amplitude');
title('Second sequence Response h(n)');
n=n1+n2-1;
if n1>n2
n3=n1-n2;
h=[h,zeros(1,n3)];
elseif n2>n1
n3=n2-n1;
x=[x,zeros(1,n3)];
end
x=[x,zeros(1,n-n1)];
h=[h,zeros(1,n-n2)];
for n=1:n
y(n)=0;
for i=1:n
j=n-i+1;
if(j<=0)
67

UR11EC098

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');
ylabel('Amplitude');
title('Circular Convoluted sequence Response');
Command window :

OUTPUT :

68

UR11EC098

69

UR11EC098

RESULT:
The linear and circular convolutions are
performed by using MATLAB script and the
program results are verified by manual calculation.
FLOWCHART:

70

UR11EC098

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

UR11EC098

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

UR11EC098

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

UR11EC098

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.
ALGORITHM/PROCEDURE:
1. Click on the MATLAB icon on the desktop
(or go to Start - All Programs and click on
MATLAB) to get into the Command
Window
74

UR11EC098

2. Type edit in the MATLAB prompt >>


that appears in the Command window.
3. Write the program in the Edit window and
save it as m-file
4. Run the program
5. Enter the input in the command window
6. The result is displayed in the Command
window

and

the

graphical

output

is

displayed in the Figure Window


Source Code :
clc;
clear all;
close all;
%Get the sequence from user
disp('The sequence from the user:');
xn=input('Enter the input sequence x(n):');
% To find the length of the sequence
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

UR11EC098

%code block to plot the input sequence


t=0:N-1;
subplot(3,2,1);
stem(t,xn);
ylabel ('Amplitude');
xlabel ('Time Index');
title ('Input Sequence');
%code block to plot the X(k)
disp('The discrete fourier transform of x(n):');
disp(Xk);
t=0:N-1;
subplot(3,2,2);
stem(t,Xk);
ylabel ('Amplitude');
xlabel ('Time Index');
title ('X(k)');
% 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);
ylabel ('Amplitude');
xlabel ('K');
title ('Magnitude Response');
%To find the phases of individual DFT points
phase=angle(Xk);
%code block to plot the phase response
disp('The phase response of X(k):');
disp(phase);
t=0:N-1;
subplot(3,2,4);
76

UR11EC098

stem(t,phase);
ylabel ('Phase');
xlabel ('K');
title ('Phase Response');
% Code block to find the IDFT of the sequence
for n=0:N-1
for k=0:N-1
iXk(n+1)=iXk(n+1)+
(Xk(k+1)*exp(i*2*pi*k*n/N));
end
end
iXk=iXk./N;
%code block to plot the output sequence
t=0:N-1;
subplot(3,2,5);
stem(t,xn);
ylabel ('Amplitude');
xlabel ('Time Index');
title ('IDFT sequence');
%code block to plot the FFT of input sequence
using inbuilt function
x2=fft(xn);
subplot(3,2,6);
stem(t,x2);
ylabel ('Amplitude');
xlabel ('Time Index');
title ('FFT of input sequence');
Command Window :

77

UR11EC098

OUTPUT :

78

UR11EC098

RESULT:
The program for DFT calculation was
performed with library functions and without
library functions. The results were verified by
manual calculation.

79

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

80

UR11EC098

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

UR11EC098

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] =
82

1 N 1
X(k )WN nk
N n0

UR11EC098

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

UR11EC098

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

UR11EC098

diffft(x) is the discrete Fourier transform (DFT)


of vector x in Frequency domain decimation
ALGORITHM/PROCEDURE:
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

UR11EC098

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');
ylabel('Amplitude');
title('Real part of the output');
subplot(2,2,2);
stem(im1);
xlabel('Time period');
ylabel('Amplitude');
title('Imaginary part of the output');
%%dit_ifft
N=input('Enter the number of elements:');
for i=1:N
re(i)= input('Enter the real part of the element:');
im(i)= input('Enter the imaginary part of the
element:');
end
for i=1:N
re(i)=re(i);
im(i)=-im(i);
end
%% call dit_ifft function
[re1,im1]=ditifft(re,im,N);
for i=1:N
re1(i)=re1(i)/N;
im1(i)=-im1(i)/N;
end
disp(re1);
86

UR11EC098

disp(im1);
%figure(2)
subplot(2,2,3);
stem(re1);
xlabel('Time period');
ylabel('Amplitude');
title('Real part of the output');
subplot(2,2,4);
stem(im1);
xlabel('Time period');
ylabel('Amplitude');
title('Imaginary part of the output');
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

UR11EC098

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)
%UNTITLED2 Summary of this function goes
here
% Detailed explanation goes here
N1=N-1;
N2=N/2;
j=N2+1;
M=log2(N);
%Bit reversal sorting
88

UR11EC098

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

UR11EC098

end
end

Command Window:

Output:

90

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);
91

UR11EC098

stem(re1);
xlabel('Time');
ylabel('Amplitude');
title('Real part of the output');
subplot(2,2,2);
stem(im1);
xlabel('Time');
ylabel('Amplitude');
title('Imaginary part of the output');
%% 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');
ylabel('Amplitude');
title('Real part of the output');
subplot(2,2,4);
stem(im1);
92

UR11EC098

xlabel('Time');
ylabel('Amplitude');
title('Imaginary part of the output');
Function Table:(DIFFFT)
function [re, im ] = diffft(re, im, N)
%UNTITLED5 Summary of this function goes
here
% Detailed explanation goes here
N1=N-1;
N2=N/2;
M=log2(N);
%%
%
for l=M:-1:1;
le=2.^l;
le2=le/2;
ur=1;
ui=0;
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

UR11EC098

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)
%UNTITLED5 Summary of this function goes
here
% Detailed explanation goes here
N1=N-1;
N2=N/2;
M=log2(N);
%%
%
for l=M:-1:1;
le=2.^l;
le2=le/2;
ur=1;
ui=0;
sr=cos(pi/le2);
si=-sin(pi/le2);
94

UR11EC098

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

UR11EC098

Enter the number of points in DIF DFT:4


Enter the real part of the element:1
Enter the imaginary part of the element:0
Enter the real part of the element:1
Enter the imaginary part of the element:0
Enter the real part of the element:1
Enter the imaginary part of the element:0
Enter the real part of the element:1
E
n
t
e
r
t
h
e
i
m
a
g
i
n
a
r
96

UR11EC098

y
p
a
rt
o
f
t
h
e
e
l
e
m
e
n
t:
0
r
e

97

UR11EC098

1
=
4

im1 =
0

Enter the number of points in DIF IFFT:4


Enter the real part of the element:4
Enter the imaginary part of the element:0
Enter the real part of the element:0
Enter the imaginary part of the element:0
Enter the real part of the element:0
Enter the imaginary part of the element:0
Enter the real part of the element:0
Enter the imaginary part of the element:0
re
1
=
1

im1 =
0
Output:

98

UR11EC098

99

UR11EC098

RESULT:
The DFT and IDFT of the given sequence
are computed using FFT algorithm both DITFFT
and DIFFFT.
FLOWCHART:

100

UR11EC098

START

ENTER THE FILTER


SPECIFICATIONS (ORDER OF
THE FILTER, CUT-OFF
FREQUENCY)

DESIGN THE FILTER

PLOT THE WAVEFORMS

STOP

101

UR11EC098

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

UR11EC098

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

UR11EC098

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

UR11EC098

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
bartlett,

as

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

UR11EC098

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.
ALGORITHM/PROCEDURE:
1.

Click on the MATLAB icon on the desktop


(or go to Start All Programs and
click on MATLAB) to get into the
Command Window.

2. Type edit in the MATLAB prompt >>


that appears in the Command window.
3. Write the program in the Edit window and

save it in M-file.
4. Run the program.
5. Enter the input in the Command Window.
6. The result is displayed in the Command

window

and

the

graphical

output

is

displayed in the Figure Window.


Source code :1
%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

UR11EC098

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;
N=input('Size of window:');
wc=input('Cut off frequency:');
h=fir1(N-1,wc/pi,'high',triang(N));
tf(h,1,1,'variable','z^-1');
freqz(h);
xlabel('Frequency');
ylabel('Magnitude');
title('FIR Filter');
Source code :3
%windows technique of Hamming using Band
pass filter
clc;
clear all;
close all;
N=input('Size of window:');
wc1=input('Lower Cut off frequency:');
wc2=input('Upper Cut off frequency:');
wc=[wc1 wc2];
h=fir1(N-1,wc/pi,'bandpass',hamming(N));
tf(h,1,1,'variable','z^-1');
freqz(h);
xlabel('Frequency');
ylabel('Magnitude');
title('FIR Filter');
107

UR11EC098

Source code :4
%windows technique of Hanning using Band stop
filter
clc;
clear all;
close all;
N=input('Size of window:');
wc1=input('Lower Cut off frequency:');
wc2=input('Upper Cut off frequency:');
wc=[wc1 wc2];
h=fir1(N-1,wc/pi,'stop',hanning(N));
tf(h,1,1,'variable','z^-1');
freqz(h);
xlabel('Frequency');
ylabel('Magnitude');
title('FIR Filter');
Source code :5
%windows technique of Blackman window using
low pass filter
clc;
clear all;
close all;
N=input('Size of window:');
wc=input('Cut off frequency:');
h=fir1(N-1,wc/pi,blackman(N));
tf(h,1,1,'variable','z^-1');
freqz(h);
xlabel('Frequency');
ylabel('Magnitude');
title('FIR Filter');
Command Window :1

108

UR11EC098

Output:1

Command Window :2

OUTPUT: 2

109

UR11EC098

Command Window :3

Output:3

110

UR11EC098

Command Window :4

Output:4

Command Window :5
111

UR11EC098

Output:

RESULT:
The given low pass filter was designed using
Window method and manually verified filter coefficient of the filters.
112

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

113

UR11EC098

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

UR11EC098

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

UR11EC098

[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

UR11EC098

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.

ALGORITHM/PROCEDURE:
1. Click on the MATLAB icon on the desktop
(or go to Start All programs and click on
117

UR11EC098

MATLAB) to get into the Command


Window.
2. Type edit in the MATLAB prompt >>
that appears in the Command window.
3. Write the program in the Edit window and
save it in M-file.
4. Run the program.
5. Enter the input in the command window.
6. The result is displayed in the Command
window

and

the

graphical

output

is

displayed in the Figure Window.

Butterworth Filters
SOURCE CODE:1
clc;
clear all;
close all;
%% Butterworth low pass Filter
% Filter Specifications
k1=input('Enter the passband gain in db:');
k2=input('Enter the stopband gain in db:');
w1=input('Enter the passband edge frequency in
rad/Sec:');
w2=input('Enter the stopband edge frequency in
rad/Sec:');
%Find the order and Cutofrf frequency using the
given specification of
%filter
[n,Wc]=buttord(w1,w2,k1,k2,'s');
disp('The order is:');
disp(n);
disp('The cutoff frequency is:');
118

UR11EC098

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);
xlabel('Frequency');
ylabel('Magnitude');
title('Magnitude response of Butterworth LPF');
% Phase response
p=angle(h);
subplot(2,1,2);
semilogx(f,p);
xlabel('Frequency');
ylabel('Phase');
title('Phase response of Butterworth LPF');
SOURCE CODE:2
clc;
clear all;
close all;
%% Butterworth high 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:');

119

UR11EC098

%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,'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);
xlabel('Frequency');
ylabel('Magnitude');
title('Magnitude response of Butterworth HPF');
% Phase response
p=angle(h);
subplot(2,1,2);
semilogx(f,p);
xlabel('Frequency');
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

UR11EC098

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
Wp=input('Enter the pass band edge frequency : ');
Ws=input('Enter the stop band edge frequency : ');
Rp=input('Enter the Pass band ripple: ');
Rs=input('Enter the stop band gain: ');
%To find order of the filter
[N]=buttord(Wp,Ws,Rp,Rs,'s')
%To find cut off frequency
Wc=[Wp Ws];
%Band stop Filtering
[b,a]=butter(N,Wc,'stop','s');
%plotting magnitude and phase response
figure(1);freqs(b,a);
Command Windows :
Using Low pass filter
121

UR11EC098

Using High pass filter

Using Band pass filter

Using Band stop filter

122

UR11EC098

OUTPUTS:
Using Low pass filter

Using High pass filter

123

UR11EC098

Using Band pass filter

124

UR11EC098

Using Band stop filter

125

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.
FLOWCHART:

126

UR11EC098

START

ENTER THE FILTER


SPECIFICATIONS (PASS,
STOP BAND GAINS AND
EDGE FREQUENCIES)

DESIGN THE ANALOG BUTTERWORTH


AND CHEBYSHEV FILTER

PLOT THE WAVEFORMS

STOP

127

UR11EC098

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

UR11EC098

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

UR11EC098

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

UR11EC098

Type I filters. In this case, Wn is in [rad/s]


and it can be greater than 1.0.
ALGORITHM/PROCEDURE:
1. Click on the MATLAB icon on the desktop
(or go to Start All programs and click on
MATLAB) to get into the Command
Window.
2. Type edit in the MATLAB prompt >>
that appears in the Command window.
3. Write the program in the Edit window and
save it in M-file.
4. Run the program.
5. Enter the input in the command window.
6. The result is displayed in the Command
window

and

the

graphical

output

is

displayed in the Figure Window.


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

UR11EC098

w2=input('Enter the stopband edge frequency in


rad/Sec:');
%Find the order and Cutofrf frequency using the
given specification of
%filter
[n,Wc]=cheb1ord(w1,w2,k1,k2,'s');
disp('The order is:');
disp(n);
disp('The cutoff frequency is:');
disp(Wc);
% Low pass filtering
[b,a]=cheby1(n,k1,w1,'low','s');
figure(1);freqs(b,a);
Source code:2
clc;
clear all;
close all;
%% Chebyshev High pass Filter
% Filter Specifications
k1=input('Enter the passband ripple in db:');
k2=input('Enter the stopband attenuation 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]=cheb1ord(w1,w2,k1,k2,'s');
disp('The order is:');
disp(n);
disp('The cutoff frequency is:');
disp(Wc);
% High pass filtering
132

UR11EC098

[b,a]=cheby1(n,k1,w1,'high','s');
figure(1);freqs(b,a);
Source code: 3
clc;
clear all;
close all;
%% Bandpass Filter Specifications
Wp=input('Enter the pass band edge frequency : ');
Ws=input('Enter the stop band edge frequency : ');
Rp=input('Enter the Pass band ripple: ');
Rs=input('Enter the stop band gain: ');
%To find order of the filter
[N]=cheb1ord(Wp,Ws,Rp,Rs,'s')
%To find cut off frequency
Wc=[Wp Ws];
%Band pass Filtering
[b,a]=cheby1(N,Rp,Wc,'bandpass','s');
%plotting magnitude and phase response
figure(1);freqs(b,a);
Source code: 4
clc;
clear all;
close all;
%% Bandstop Filter Specifications
Wp=input('Enter the pass band edge frequency : ');
Ws=input('Enter the stop band edge frequency : ');
Rp=input('Enter the Pass band ripple: ');
Rs=input('Enter the stop band gain: ');
%To find order of the filter
[N]=cheb1ord(Wp,Ws,Rp,Rs,'s')
%To find cut off frequency
133

UR11EC098

Wc=[Wp Ws];
%Bandstop Filtering
[b,a]=cheby1(N,Rp,Wc,'stop','s');
%plotting magnitude and phase response
figure(1);freqs(b,a);
Command Window :1(LPF)

Output:

134

UR11EC098

Command Window :2(HPF)

Output:

135

UR11EC098

Command Window :3(BPF)

Output:

136

UR11EC098

Command Window :4(BSF)

Output:

137

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.
138

UR11EC098

FLOWCHART:

START

ENTER THE FILTER


SPECIFICATIONS (PASS,
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

UR11EC098

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

UR11EC098

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

UR11EC098

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

UR11EC098

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

ALGORITHM/PROCEDURE:
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

UR11EC098

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

UR11EC098

% Calculation of order and cutoff freq. for the


above filter specs.
[n,Wc]=buttord(ohmp,ohms,Ap,As,'s');
% Low Pass Filtering
[b,a]=butter(n,Wc,'low','s');
[bz,az] = impinvar(b,a,T);
tf(bz,az,T);
O=linspace(-pi,pi,50);
% O is the freq. axis
H=freqz(bz,az,O);
% Magnitude Response
Hm=20*log10(abs(H));
subplot(2,1,1);
semilogx(O,Hm);
xlabel('Frequency');
ylabel('Magnitude');
title('Magnitude Response of IIR Filter using
Impulse Invariant Method');
% Phase Response
Ha=angle(H);
subplot(2,1,2);
semilogx(O,Ha);
xlabel('Frequency');
ylabel('Phase');
title('Phase Response of IIR Filter using Impulse
Invariant Method');
/ Butterworth Lowpass Bilinear
Transformation Method
clc;
clear all;
close all;
warning off;
% Design of IIR Filters
%% Filter Specifications
145

UR11EC098

% Input Wp,Ws,Sp,Ss,T
% T=1,both the ripple gains should have band
width( .1 to .3)
disp(' Butterworth Lowpass filter using Bilnear
transformation 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
% Calculation of order and cutoff freq. for the
above filter specs.
[n,Wc]=buttord(ohmp,ohms,Ap,As,'s');
% Low Pass Filtering
[b,a]=butter(n,Wc,'low','s');
[bz,az] = bilinear(b,a,1/T);
tf(bz,az,T);
O=linspace(-pi,pi,50);
% O is the freq. axis
H=freqz(bz,az,O);
% Magnitude Response
Hm=20*log10(abs(H));
subplot(2,1,1);
semilogx(O,Hm);
xlabel('Frequency');
ylabel('Magnitude');
146

UR11EC098

title('Magnitude Response of IIR Filter using


Bilinear Transformation Method');
% Phase Response
Ha=angle(H);
subplot(2,1,2);
semilogx(O,Ha);
xlabel('Frequency');
ylabel('Phase');
title('Phase Response of IIR Filter using Bilinear
Transformation Method');
/ Chebyshev 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(' Chebyshev 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;
147

UR11EC098

ohms=Ws/T;
% Chebyshev Filter
% Calculation of order and cutoff freq. for the
above filter specs.
[n,Wc2]=cheb1ord(ohmp,ohms,Ap,As,'s')
% Low Pass Filtering
[b,a]=cheby1(n,Ap,Wc2,'low','s');
[bz,az] = impinvar(b,a,T);
tf(bz,az,T);
O=linspace(-pi,pi,50);
% O is the freq. axis
H=freqz(bz,az,O);
% Magnitude Response
Hm=20*log10(abs(H));
subplot(2,1,1);
semilogx(O,Hm);
xlabel('Frequency');
ylabel('Magnitude');
title('Magnitude Response of IIR Filter using
Impulse Invariant Method');
% Phase Response
Ha=angle(H);
subplot(2,1,2);
semilogx(O,Ha);
xlabel('Frequency');
ylabel('Phase');
title('Phase Response of IIR Filter using Impulse
Invariant Method');
/Chebyshev Lowpass Bilinear
Transformation Method
clc;
clear all;
close all;
warning off;
148

UR11EC098

% 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(' Chebyshev Lowpass filter using Bilnear
transformation 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;
% Chebyshev Filter
% Calculation of order and cutoff freq. for the
above filter specs.
[n,Wc2]=cheb1ord(ohmp,ohms,Ap,As,'s')
% Low Pass Filtering
[b,a]=cheby1(n,Ap,Wc2,'low','s');
[bz,az] = bilinear(b,a,1/T);
tf(bz,az,T);
O=linspace(-pi,pi,50);
% O is the freq. axis
H=freqz(bz,az,O);
% Magnitude Response
Hm=20*log10(abs(H));
subplot(2,1,1);
semilogx(O,Hm);
xlabel('Frequency');
ylabel('Magnitude');
149

UR11EC098

title('Magnitude Response of IIR Filter using


Bilinear Transformation Method');
% Phase Response
Ha=angle(H);
subplot(2,1,2);
semilogx(O,Ha);
xlabel('Frequency');
ylabel('Phase');
title('Phase Response of IIR Filter using Bilinear
Transformation Method');

/ Butterworth Lowpass Impulse


invariant method
Command window:

Output:

150

UR11EC098

/ Butterworth Lowpass Bilinear


Transformation Method
Command Window :

151

UR11EC098

Output:

/ Chebyshev Lowpass Impulse invariant


method
Command Window:

152

UR11EC098

Output:

/Chebyshev Lowpass Bilinear


Transformation Method
153

UR11EC098

Command Window:

Output:

154

UR11EC098

RESULT:
Butterworth and Chebyshev Lowpass filters
were

designed

using

Bilinear

and Impulse

Invariant transformations, and manually verified

155

UR11EC098

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

UR11EC098

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

UR11EC098

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

UR11EC098

not equal to 1, filter normalizes the filter


coefficients by a(1). If a(1) equals 0, filter
returns an error.
ALGORITHM/PROCEDURE:
1. Click on the MATLAB icon on the desktop
(or go to Start All Programs and click on
MATLAB) to get into the Command
Window
2. Type edit in the MATLAB prompt >>
that appears in the Command window.
3. Write the program in the Edit window and
save it in M-file
4. Run the program
5. Enter the input in the command window
6. The result is displayed in the Command
window

and

the

graphical

output

is

displayed in the Figure Window


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

UR11EC098

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');
xlabel('Frequency');
ylabel('Magnitude');
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');
xlabel('Frequency');
ylabel('Magnitude');
title('Impulse Response IIR Filter');
PROGRAM 2
clc;
clear all;
close all;
%% Input the samples
% Time domain Response of FIR filter
N=16; %Input samples
k=0:N-1;
160

UR11EC098

x(1:N)=1;
b0=1; b1= -1; b2=-2;
B=[b0,b1,b2]; %Numerator coeff.
A=1; %Denominator coeff.
%Filtering
y=filter(B, A ,x);
%plot the graph
subplot(2,2,1);
stem(k,x,'r');
xlabel('Time');
ylabel('Unit step signal');
title('Unit step input signal');
subplot(2,2,2);
stem(k,y,'r');
xlabel('Frequency');
ylabel('Magnitude');
title('Step Response FIR filter');
% Time domain response of IIR filter
N1=10; %Input samples
k1=0:N1-1;
x1(1:N1)=1;
B1=1;
a=0.8;
A1=[1,-a];
y1=filter(B1, A1 ,x1);
%plot the graph
subplot(2,2,3);
stem(k1,x1,'r');
xlabel('Time');
ylabel('Unit step input');
title('Unit step input signal');
subplot(2,2,4);
stem(k1,y1,'r');
xlabel('Frequency');
ylabel('Magnitude');
title('Step Response IIR Filter');
Output for Unit impulse input:
161

UR11EC098

Output for Unit step input:

162

UR11EC098

RESULT:

163

UR11EC098

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

UR11EC098

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

UR11EC098

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

UR11EC098

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

UR11EC098

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
ALGORITHM/PROCEDURE:
1. Click on the MATLAB icon on the desktop
(or go to Start All programs and click on
MATLAB) to get into the Command
Window
2. Type edit in the MATLAB prompt >>
that appears in the Command window.
3. Write the program in the Edit window and
save it in M-file.
4. Run the program.
5. Enter the input in the command window.
6. The result is displayed in the Command
window

and

the

graphical

output

is

displayed in the Figure Window.


SOURCE CODE:
clc;
clear all;
close all;
%Frequency Response
168

UR11EC098

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

UR11EC098

RESULT:
The frequency response (magnitude and
phase response) of the given system was found
using MATLAB.
170

UR11EC098

171

UR11EC098