Theory
Filters are essential components in many
communication systems. Filters can be used in samplers and down samplers as an
antialias filters. Also filters can be used in modulators and demodulators,
reconstruction filters in in receivers. Also filters can be used in some
control systems and in almost every signal processing components.
Filters can be classified as either an analogue or
digital filters. In this experiment we will be interested in digital filters
only.
Digital
filters can also be classified as either a Finite Impulse Response (FIR) or an
Infinite Impulse Response (IIR) filters.
A finite
impulse response (FIR) filter is a type of a signal processing filter whose
impulse response (or response to any finite length input) is of finite
duration, because it settles to zero in finite time. However the response time
for an IIR filter will extends to an infinite.
A comparison
between FIR and IIR filters show that IIR requires less coefficient; hence
faster computation of the filtered signal; compared with FIR filters. However
IIR filters have a nonlinear phase distortion whereas FIR filters has a linear
phase response.
In this
experiment only FIR filters will be considered while IIR filters will be
discussed in more details in the next experiment.
To design an FIR filter, it is necessary to
compute the filter coefficients by either windowing or using one the various
algorithms presented by digital signal processing course. However the
calculation of the filter coefficients is greatly simplified by using
commercial software such as MATLAB and digifilter.
FIR filters can be implemented in hardware
by using the structure shown in Figure 1.
Note that filters are considered linear
time invariant system. This means that if an input signal is passed through the input terminal of a
given filter then the output of that filter is given by the convolution sum
described by .
Experimental procedures
In
this experiment we will implement and test low pass filter, high pass filter,
bandpass filter and band stop (notch) filter as illustrated by the following
exercises.
Low pass filter
In
this experiment you will design a low pass filter whose cutoff frequency is . In order to design this filter do the
following steps
1.
In
MATLAB open the filter design tool by typing the fdatool in the MATLAB command
window. Aa design window such as the one shown in Figure 2 will appear on the screen.
1.
Set
the response type to Low pass filter, the design method to FIR window, filter
order 50, window Hamming, sampling frequency to and the
carrier frequency
2.
Press
on the design button to design the filter.
3.
In
order to obtain the filter coefficients go the file menu then select export. A
small dialog box such as the one shown in Figure
3 will appear. Select export to coefficient File
(ASCII) and press on the export button. Name your file as “lpf.cof” and save it
under your project directory. The file contains the filter coefficient that is
needed by project.
1.
Modify
the filter coefficient file by adding the following two statements
#define N 89 //number of coefficients
float h[N]={ add the coeffients of the filter here}

2.
To
implement the filter on the DSK6713 kit open the existing project that you
worked on last time and add the following c code to it.
#include "lpf.cof"
//coefficient file
#include
"dsk6713_aic23.h"
//codecdsk support file
Uint32
fs=DSK6713_AIC23_FREQ_8KHZ;
//set sampling rate
signed intyn = 0;
//initialize filter's output
short dly[N];
//delay samples
interrupt void c_int11()
//ISR
{
short i;
dly[0]=input_sample();
//input newest sample
yn = 0;
//initialize filter's output
for (i = 0; i< N; i++)
yn += (h[i] * dly[i]);
//y(n) += h(i)* x(ni)
for (i = N1; i > 0; i)
//starting @ end of buffer
dly[i] = dly[i1];
//update delays with data move
output_sample(yn);
//output filter sample
return;
}
void main()
{
comm_intr();
//init DSK, codec, McBSP
while(1);
//infinite loop
}

3.
After
you build the project, load it on the DSK6713 kit, then run the program.
4.
To
test the designed LPF filter, connect a sine wave from the function generator
to the LINE IN terminal of the DSK6713 kit.
Set
the amplitude of the sign wave to and vary
the frequency of the sine wave from 50 Hz to 3.4 kHz in steps of 200 Hz.
Measure the amplitude of the output wave at every frequency point
Plot the amplitude versus frequency and comment on the results
Low pass, high pass, band pass and pass band filter
In
this exercise we will design four filters using the same procedure used in the
previous section. The student is supposed to design the four filter types in
MATLAB then export the filters coefficients to a different file depending on
the filter type.
A
slider can be used to select which filter to use as illustrated by the
following c source file. Select the cutoff frequency of the low pass filter as , the cut off
frequency of the High pass filter as , the center frequency of the bandpass filter
as , and the band stop of the band stop filter as
* Description :This Program tells
about the Finite Impulse Response.
FIR
filter:
lowpass
1500 Hz,
High
pass,2200hz,
bandpass
1750 hz,
bandstop
790 hz.
we
can select desires filter by varying slider in gel file
**********************************************************************************************/
#include
"DSK6713_AIC23.h" //this
file is added to initialize the DSK6713
#include "lowp1500.cof" // coefficient of
lowpass filter file calculated from MATLAB
#include "highp2200.cof" // coefficient of highpass
filter file calculated from MATLAB
#include "bpass1750.cof" // coefficient of bandpass
filter file calculated from MATLAB
#include "bstop790.cof" // coefficient of
bandstop filter file calculated from MATLAB
Uint32 fs=DSK6713_AIC23_FREQ_8KHZ; // set the sampling frequency,
Different sampling frequencies supported by AIC23 codec are 8, 16, 24, 32,
44.1, 48, and 96 kHz.
short FIR_number = 0; //filter number
signed intyn = 0; //variable
declaration
short dly[N]; //declare delay
buffer of n values
float h[4][N]; //coefficients of 4
different filters
interrupt void c_int11() // ISR call, At each Interrupt, program
execution goes to the interrupt service routine
{
short
i; //variable
declaration
dly[0]
= input_sample(); //newest input @ top of buffer
yn
= 0; //initialize filter output
for
(i = 0; i< N; i++) //for
loop takes in the value of i from 0 to N
yn
+=(h[FIR_number][i]*dly[i]); //y(n)
+= h(LP#,i)*x(ni)
for
(i = N1; i > 0; i) //starting
@ bottom of buffer
dly[i]
= dly[i1]; //update delays with data move
output_sample(yn>>
15); //output
filter,the value in the buffer yn indexed by the variable loop is written on
to the codec.
return; //
program execution goes back to while(1) and then again starts listening for
next interrupt and this process goes on
}
void main()
{
short
i; //variable
declaration
for
(i=0; i<N; i++) //for
loop which takes in the value of i from 0 to N=4 and switches to corresponding
filter coefficients
{
dly[i]
= 0; //init buffer
h[0][i]
= hlp[i]; //start addr of lp1500 coeff
h[1][i]
= hhp[i]; //start addr of hp2200 coeff
h[2][i]
= hbp[i]; //start
addr of bp1750 coeff
h[3][i]
= hbs[i]; //start
addr of bs790 coeff
}
comm_intr(); // ISR function is called, using the given command
while(1); //program
execution halts and it starts listening for the interrupt which occur at
every sampling period Ts.
}

You
need also to add the following GEL file to your project.
Effects on Voice Using Three FIR Low pass Filters
(FIR3LP)
In
this exercise you will implement three FIR low pass filters with cutoff
frequencies at 600, 1500, and 3000Hz, respectively. The three low pass filters
were designed with MATLAB’s fdatool to yield the corresponding three sets of
coefficients.
If
for example LP_number is set to 0, h[0][i] is equal to hlp600[i] (within the
“for” loop in the function main), which is the address of the first set of
coefficients. The coefficients file LP600.cof represents an 81coefficient FIR
low pass filter with a 600Hz cutoff frequency, using the Kaiser window
function. your program may appear as the one shown below. LP_number can be
changed to 1 or 2 to implement the 1500 or 3000Hz low pass filter,
respectively.
//Fir3LP.c
FIR using 3 low pass coefficients with three different BW
#include
"lp600.cof" //coeff file LP @ 600 Hz
#include
"lp1500.cof" //coeff file LP @ 1500 Hz
#include
"lp3000.cof" //coeff file LP @ 3000 Hz
#include
"dsk6713_aic23.h" //codecdsk support file
Uint32
fs=DSK6713_AIC23_FREQ_8KHZ; //set sampling rate
short
LP_number = 0; //start with 1st LP filter
signed
intyn = 0; //initialize filter's output
short
dly[N]; //delay samples
float
h[3][N]; //filter characteristics 3xN
interrupt
void c_int11() //ISR
{
short
i;
dly[0]
= input_sample(); //newest input @ top of buffer
yn
= 0; //initialize filter output
for
(i = 0; i< N; i++)
yn
+=(h[LP_number][i]*dly[i]); //y(n) += h(LP#,i)*x(ni)
for
(i = N1; i > 0; i) //starting @ bottom of buffer
dly[i]
= dly[i1]; //update delays with data move
output_sample(yn>>
15); //output filter
return;
//return from interrupt
}
void
main()
{
short
i;
for
(i=0; i<N; i++)
{
dly[i]
= 0; //init buffer
h[0][i]
= hlp600[i]; //start addr of LP600 coeff
h[1][i]
= hlp1500[i]; //start addr of LP1500 coeff
h[2][i]
= hlp3000[i]; //start addr of LP3000 coeff
}
comm_intr();
//init DSK, codec, McBSP
while(1);
//infinite loop
}

With
the GEL file FIR3LP.gel, one can vary LP_number from 0 to 2 and slide through
the three different filters. Build this project as FIR3LP. Use a .wav file from
your PC as input and observe the effects of the three low pass filters on the
input voice. Connect the LINE OUT of the DSK6713 to a speaker and observe what
happens when the different filters are used
Your
GEL file may appear as shown below
/*FIR3LP.gel
Gel file to step through three different LP filters*/
menuitem
"Filter Characteristics"
slider
Filter(0,2,1,1,filterparameter) /*from 0 to 2,incr by 1*/
{
LP_number
= filterparameter; /*for 3 LP filters*/
}

Voice Scrambling Using Filtering and Modulation
(Scrambler)
This exercise illustrates a voice
scrambling/descrambling scheme. The approach makes use of basic algorithms for
filtering and modulation. With voice as input, the resulting output is
scrambled voice. The original unscrambled voice is recovered when the output of
the DSK is used as the input to a second DSK running the same program.
The scrambling method used is
commonly referred to as frequency inversion. It takes an audio range,
represented by the band 0.3 to 3 kHz, and “folds” it about a carrier signal.
The frequency inversion is achieved by multiplying (modulating) the audio input
by a carrier signal, causing a shift in the frequency spectrum with upper and
lower sidebands. On the lower sideband that represents the audible speech
range, the low tones are high tones, and vice versa.
Figure
4 is a block diagram of the scrambling scheme. At point
A we have a bandlimited signal 0 to 3 kHz. At point B we have a
doublesideband signal with suppressed carrier. At point C the upper sideband
is filtered out. Its attractiveness comes from its simplicity, since only
simple DSP algorithms are utilized: filtering, and sine generation and
modulation.
No comments:
Post a Comment