Dsp manual print

1. TO STUDY THE ARCHITECTURE OF DSP CHIPS -
TMS 320C SX/6X INSTRUCTIONS.
The C6711™ DSK builds on TI's industry-leading line of low cost, easy-to-use DSP Starter
Kit (DSK) development boards. The high-performance board features the
TMS320C6711 floating-point DSP. Capable of performing 900 million floating-point
operations per second (MFLOPS), the C6711 DSP makes the C6711 DSK the most
powerful DSK development board on the market.
The DSK is a parallel port interfaced platform that allows TI, its customers, and thirdparties,
to efficiently develop and test applications for the C6711. The DSK consists of a C6711-
based printed circuit board that will serve as a hardware reference design for TI’s
customers’ products. With extensive host PC and target DSP software support,
including bundled TI tools, the DSK provides ease-of-use and capabilities that are
attractive to DSP engineers.
TMS320C6711 DSK Block Diagram
The basic function block diagram and interfaces of the C6711 DSK are displayed
below.
Many of the parts of the block diagram are linked to specific topics.

The C6711 DSK board is displayed below.
Many of the parts of the board illustration are linked to specific topics. Move the mouse
over the illustration to determine which parts are linked. Click on the portion of the illustration
for which you want to see information.
The C6711DSK has the following features:
• 150-MHz C6711DSP capable of executing 900 million floating-point
operations per second (MFLOPS)
• Dual clock support; CPU at 150MHz and external memory interface (EMIF) at
100MHz
• Parallel port controller (PPC) interface to standard parallel port on a host PC
(EEP or bi-directional SPP support)
• 16M Bytes of 100 MHz synchronous dynamic random access memory
(SDRAM)
• 128K Bytes of flash programmable and erasable read only memory (ROM)
• 8-bit memory-mapped I/O port
• Embedded JTAG emulation via the parallel port and external XDS510 support
• Host port interface (HPI) access to all DSP memory via the parallel port
• 16-bit audio codec
• Onboard switching voltage regulators for 1.8 volts direct current (VDC) and
3.3 VDC
The C6711 DSK has approximate dimensions of 5.02 inches wide, 8.08 inches long
and 0.7 inches high. The C6711 DSK is intended for desktop operation while
connected to the parallel port of your PC or using an XDS510 emulator. The DSK
requires that the external power supply be connected in either mode of operation (an

external power supply and a parallel cable are provided in the kit).
The C6711 DSK has a TMS320C6711 DSP onboard that allows full-speed
verification of code with Code Composer Studio. The C6711 DSK provides:
• a parallel peripheral interface
• SDRAM and ROM
• a 16-bit analog interface circuit (AIC)
• an I/O port
• embedded JTAG emulation support
Connectors on the C6711 DSK provide DSP external memory interface (EMIF) and
peripheral signals that enable its functionality to be expanded with custom or third party
daughter boards.
The DSK provides a C6711 hardware reference design that can assist you in the
development of your own C6711-based products. In addition to providing a reference for
interfacing the DSP to various types of memories and peripherals, the design also
addresses power, clock, JTAG, and parallel peripheral interfaces.

Top Side of the Board:
Bottom Side of the Board:

TMS320C6711 DSP Features:
• VelociTI advanced very long instruction word (VLIW) architecture
• Load-store architecture
• Instruction packaging for reduced code size
• 100% conditional instructions for faster execution
• Intuitive, reduced instruction set computing with RISC-like instruction set
• CPU
• Eight highly independent functional units (including six ALUs and two
multipliers)
• 32 32-bit general-purpose registers
• 900 million floating-point operations per second (MIPS)
• 6.7-ns cycle time
• Up to eight 32-bit instructions per cycle
• Byte-addressable (8-, 16-, 32-bit data)
• 32-bit address range
• 8-bit overflow protection
• Little- and big-endian support
• Saturation
• Normalization
• Bit-field instructions (extract, set, clear)
• Bit-counting
• Memory/peripherals

L1/L2 memory architecture:
32K-bit (4-K byte) L1P program cache (direct mapped)
32K-bit (4K-byte) L1D data cache (2-way set-associative)
512K-bit (64K byte) L2 unified map RAM/cache (flexible data/program allocation) 32-bit
external memory interface (EMIF):
Glue less interface to synchronous memories: SDRAM and SBSRAM Glue
less interface to asynchronous memories: SDRAM and EPROM Enhanced
direct-memory-access (EDMA) controller
16-bit host-port interface (HPI) (access to entire memory map) Two
multi-channel buffered serial ports (McBSPs)
Two 32-bit general-purpose timers
Flexible phase-locked-loop (PLL) clock generator
Miscellaneous
IEEE-1149.1 (JTAG) boundary-scan-compatible for emulation and test support 256-
lead ball grid array (BGA) package (GFN suffix)
0.18-mm/5-level metal process with CMOS technology
3.3-V I/Os, 1/8-V internal
C67x (Specific) Floating-Point Instructions:
Alphabetical Listing of 'C67x (Specific) Floating-Point Instructions A - F
G - L M - R S - Z
ABSDP INTDP MPYDP SPDP
ABSSP INTDPU MPYI SPINT
ADDAD INTSP MPYID SPTRUNC
ADDDP INTSPU MPYSP SUBDP
ADDSP LDDW RCPDP SUBSP
CMPEQDP RCPSP

CMPEQSP RSQRDP
CMPGTDP RSQRSP
CMPGTSP
CMPLTDP
CMPLTSP
DPINT
DPSP
DPTRUNC

2. TO VERIFY LINEAR CONVOLUTION
Aim: To compute the linear convolution of two discrete sequences.
Theory: Consider two finite duration sequences x (n) and h (n), the duration of x
(n) is n1 samples in the interval 0 ≤n≤ (n1 −1). The duration of h (n) is n2 samples;
that is h (n) is non - zero only in the interval 0 ≤n≤ (n2 −1) . The linear or a periodic
convolution of x (n) and h (n) yields the sequence y (n) defined as,
n
Y (n) =
∑
h(m)x(n
−m)
m=0
Clearly, y (n) is a finite duration sequence of duration (n1+n2 -1) samples.
The convolution sum of two sequences can be found by using following steps
Step1: Choose an initial value of n, the starting time for evaluating the output
sequence y (n). If x (n) starts at n=n1 and h (n) starts at n= n2 then n = n1+ n2-1 is a
good choice.
Step2: Express both sequences in terms of the index m.
Step3: Fold h (m) about m=0 to obtain h (-m) and shift by n to the right if n is positive and
left if n is negative to obtain h (n-m).
Step4: Multiply two sequences x (n-m) and h (m) element by element and sum the
products to get y (n).
Step5: Increment the index n, shift the sequence x (n-m) to right by one sample and repeat
step4.
Step6: Repeat step5 until the sum of products is zero for all remaining values of n.
Program:
%Linear convolution of two sequences
a=input('enter the input sequence1=');
b=input('enter the input sequence2=');
n1=length (a)
n2=length (b)
x=0:1:n1-1;
Subplot (2, 2, 1), stem(x, a); title
('INPUT SEQUENCE1'); xlabel
('---->n');
ylabel ('---->a (n)');
y=0:1:n2-1;

subplot (2, 2, 2), stem(y, b); title
('INPUT SEQUENCE2'); xlabel
('---->n');
ylabel('---->b(n)');
c=conv (a, b)
n3=0:1:n1+n2-2;
subplot (2, 1, 2), stem (n3, c);
title ('CONVOLUTION OF TWO SEQUENCES');
xlabel ('---->n');
ylabel ('---->c (n)');
Output:
Enter the input sequence1=
C=
n1 =
n2 =
c =
Result:
Inference: The length of the Linear convolved sequence is n1+n2-1 where n1and n2 are
lengths of sequences.
VIVA Questions
1. What do you understand by Linear Convolution.
2. What are the properties of convolution.

3. TO VERIFY CIRCULAR CONVOLUTION
Aim: To compute the circular convolution of two discrete sequences.
Theory: Two real N-periodic sequences x(n) and h(n) and their circular or periodic
convolution sequence y(n) is also an N- periodic and given by,
N
y(n) = 1
∑
−h(m)x((n
−m))N
, for n=0 to N-1.
m=0
Circular convolution is some thing different from ordinary linear convolution
operation, as this involves the index ((n-m))N, which stands for a ‘modula-N’
operation. Basically both type of convolution involve same six steps. But the
difference between the two types of convolution is that in circular convolution the
folding and shifting (rotating) operations are performed in a circular fassion by
computing the index of one of the sequences with ‘modulo-N’ operation. Either one of the
two sequences may be folded and rotated without changing the result of circular
convolution. That is,
N
y(n) = 1
∑
−x(m
)h((n −m))N
, for n=0 to (N-1).
m=0
If x (n) contain L no of samples and h (n) has M no of samples and that L > M, then
perform circular convolution between the two using N=max (L,M), by adding (L-M) no
of zero samples to the sequence h (n), so that both sequences are periodic with
number.
Two sequences x (n) and h (n), the circular convolution of these two sequences
can be found by using the following steps.
1. Graph N samples of h (n) as equally spaced points around an outer circle in
counterclockwise direction.
2. Start at the same point as h (n) graph N samples of x (n) as equally spaced
points around an inner circle in clock wise direction.
3. Multiply corresponding samples on the two circles and sum the products to
produce output.
4. Rotate the inner circle one sample at a time in counter clock wise direction
and go to step 3 to obtain the next value of output.
5. Repeat step No.4 until the inner circle first sample lines up with first sample of
the exterior circle once again.

Program:
%circular convolution
a=input('enter the input sequence1=');
b=input('enter the input sequence2=');
n1=length (a)
n2=length (b)
n3=n1-n2
N=max (n1, n2);
if (n3>0)
b= [b, zeros (1, n1-n2)]
n2=length (b);
else
a= [a, zeros (1, N-n1)]
n1=length (a);
end;
k=max (n1, n2);
a=a';
b=b';
c=b;
for i=1: k-1
b=circshift (b, 1);
c=[c, b];
end;
disp(c);
z=c*a;
disp ('z=')
disp (z)
subplot (2, 2, 1);
stem (a,'filled');
title ('INPUT SEQUENCE1');
xlabel ('---->n');
ylabel ('---->Amplitude')
subplot (2, 2, 2);
stem (b,'filled');
title ('INPUT SEQUENCE2'); xlabel ('---->n');
ylabel ('---->Amplitude');
subplot (2, 1, 2);
stem (z,'filled');

title ('CONVOLUTION OF TWO SEQUENCES');
xlabel ('---->n');
Output:
n1 =
n2 =
n3 =
b =
z=
Result:
Inference: The length of the circularly convolved sequence is max (n1, n2) where n1 and
n2 are the lengths of given sequences.
Questions & Answers
1. Define circular convolution?
2. What do you understand by periodic convolution?

4. DESIGN FIR FILTER (LP/HP) USING WINDOWING
TECHNIQUE
a) USING RECTANGULAR WINDOW
Aim: To design FIR high pass filter using rectangular window.
Theory: The design frequency response Hd (ejw
) of a filter is periodic in frequency and
can be expanded in a Fourier series. The resultant series is given by
∞
−jwn
H
d
(e
jw
) =
Where
Hd(n) =
∑ hd (n)e
n=−∞
Π
jω
1/2Π ∫ H(e )e
−Π
jωn
dω
and known as fourier coefficients having infinite length. One possible way of
obtaining FIR filter is to truncate the infinite fourier series at n = +/- [N-1/2], Where N
is the length of the desired sequence. But abrupt truncation of the Fourier series
results in oscillation in the passband and stopband. These oscillations are due to
slow convergence of the fourier series and this effect is known as the Gibbs
phenomenon. To reduce these oscillations, the Fourier coefficients of the filter are
modified by multiplying the infinite impulse response with a finite weighing sequence
ω (n) called a window.
where
ω (n) = ω (-n) ≠ 0 for |n| [≤ (N-1/2]/2]
=0 for |n|> (N-1/2]/2]
After multiplying window sequence ω (n) with hd (n), we get a finite duration
sequence h (n) that satisfies the desired magnitude response.
h (n) = hd(n) ω (n) for all |n|≤[N-1/2]
=0 for |n|> [N-1/2]
The frequency response H (ejw
) so the filter can be obtained by convolution of Hd(eJW
) and W
(ejw
) given by
Π
H(ejw
) = 1/ 2Π ∫ H d(e
−Π
Hd(ejw
) * W (ejw
)
jθ j (ω −θ )
)W(e dθ
Because both Hd (ejw
) and W (ejw
) are periodic function, the operation often called as
periodic convolution.

The rectangular window sequence is given by
WR (n) = 1 for - (N-1/2 ≤ n ≤ (n-1)/2
= 0 otherwise
Program:
%Design of high pass filter using rectangular window
WC=0.5*pi;
N=25;
b=fir1 (N-1, wc/pi,'high', rectwin (N)); disp
('b=');
disp (b)
w=0:0.01: pi;
h=freqz (b, 1, w);
plot (w/pi, abs (h));
xlabel ('Normalised Frequency');
ylabel ('Gain in dB')
title ('FREQUENCY RESPONSE OF HIGHPASS FILTER USING
RECTANGULAR WINDOW');
Output:
Result: FIR high pass filter is designed by using rectangular window.

Inference: Magnitude response of FIR high pass filter designed using
Rectangular window as significant sidelobes.
Questions & Answers
1. What are "FIR filters"?
2. What does "FIR" mean?
3. Why is the impulse response "finite"?
4. How do you pronounce "FIR"?
5. What is the alternative to FIR filters?
6. How do FIR filters compare to IIR filters?
7. What are the advantages of FIR Filters (compared to IIR filters)?
8. What are the disadvantages of FIR Filters (compared to IIR filters)?
9. What terms are used in describing FIR filters?
b) USING KAISER WINDOW
Aim: To design FIR low pass filter using Kaiser Window for different values of
Beeta and verify its characteristics.
Theory: The Kaiser window is given by
2
Wk (n) = Io [α (1−(2n/ N−1) )/ I0(α)] for |n| ≤ N-1/2
=0 otherwise
Where α is an independent parameter.
Io
(x) is the zeroth order Bessel function of the first kind
∞
k 2
I
0
(x) = 1+
∑
[1/k! (x/2)]
k=1
Advantages of Kaiser Window
1. It provides flexibility for the designer to select the side lobe level and N.
2. It has the attractive property that the side lobe level can be varied
continuously from the low value in the Blackman window to the high value
in the rectangular window.

Program:
%Design of FIR lowpass filter using Kaiser Window
WC=0.5*pi;
N=25;
b=fir1 (N, wc/pi, kaiser (N+1, 0.5))
w=0:0.01: pi;
h=freqz (b, 1, w);
plot (w/pi, 20*log10 (abs (h)));
hold on
w=0:0.01: pi;
h=freqz (b, 1, w);
hold on
w=0:0.01: pi;
h=freqz (b, 1, w);
ylabel ('Magnitude in dB');
title ('FREQUENCY RESPONSE OF LOWPASS FILTER USING
KAISER WINDOW');
hold off
Output:

Result:
Inference: The response of stop band improves as beeta increases.
Questions & Answers
1. What are the design techniques of designing FIR filters?
2. What is the reason that FIR filter is always stable?
3. What are the properties of FIR filter?

5. DESIGN IIR FILTER (LP/HP)
a)
Aim: To design IIR Butterworth low pass filter and verify its characteristics.
Theory: The most common technique used for designing IIR digital filters known
as indirect method, involves first designing an analog prototype filter and then
transforming the prototype to a digital filter. For the given specifications of a digital
filter, the derivation of the digital filter transfer function requires three steps.
1. Map the desired digital filter specifications into those for an equivalent
analog filter.
2. Derive the analog transfer function for the analog prototype.
3. Transform the transfer function of the analog prototype into an equivalent
digital filter transfer function.
There are several methods that can be used to design digital filters having an infinite during
unit sample response. The techniques described are all based on converting an analog
filter into digital filter. If the conversion technique is to be effective, it should posses
the following desirable properties.
1. The jΩ-axis in the s-plane should map into the unit circle in the z-plane.
Thus there will be a direct relationship between the two frequency
variables in the two domains.
2. The left-half plane of the s-plane should map into the inside of the unit
circle in the z-plane. Thus a stable analog filter will be converted to a
stable digital filter.
Design a digital filter using impulse invariance method
1. For the given specifications, find Ha (s), the transfer function of an analog
filter.
2. Select the sampling rate of the digital filter, T seconds per sample.
3. Express the analog filter transfer function as the sum of single-pole filters.
N
Ha (s) = ∑K =1
ck / s − p
k

4. Compute the z-transform of the digital filter by using the formula
N
H (z) = ∑K =1
For high sampling rates use
N
c /1
k
Tc
pkT −1
− e z
pkT −1
/1 − e z
H (z) = ∑ k
K =1
Design digital filter using bilinear transform technique.
1. From the given specifications, find prewarping analog frequencies using formula Ω=
2/T tan w/2.
2. Using the analog frequencies find H (s) of the analog filter.
3. Select the sampling rate of the digital filter, call it T seconds per sample.
4. Substitute s= 2/T (1-z-1
/1+ z-1
) into the transfer function found in step2.
Program:
%Design of IIR Butterworth lowpass filter
alphap=input ('enter the pass band attenuation=');
alphas=input ('enter the stop band attenuation=');
fp=input ('enter the passband frequency=');
fs=input ('enter the stop band frequency=');
F=input ('enter the sampling frequency=');
omp=2*fp/F;
oms=2*fs/F;
[n, wn]=buttord (omp, oms, alphap, alphas) [b,
a]=butter (n, wn)
w=0:0.1: pi;
[h, ph]=freqz (b, a, w);
m=20*log (abs (h));
an=angle (h);
subplot (2, 1, 1);

plot (ph/pi, m);
grid on;
ylabel ('Gain in dB');
title (‘FREQUENCY RESPONSE OF BUTTERWORTH LOWPASS
subplot (2, 1, 2);
title (‘PHASE RESPONSE OF BUTTERWORTH LOWPASS FILTER’); plot
(ph/pi, an);
grid on;
ylabel ('Phase in Radians');
Output:
Enter the pass band attenuation=
Enter the stop band attenuation=
Enter the pass band frequency=
Enter the stop band frequency=
Enter the sampling frequency=
n =
Wn =
b =
a =
Result:
Inference: There are no ripples in the passband and stopband.
Questions & Answers
1. What are the advantages of IIR filters (compared to FIR filters)? What are IIR
filters? What does "IIR" mean?
2. Why is the impulse response "infinite"?
3. What is the alternative to IIR filters?
4. What are the disadvantages of IIR filters (compared to FIR filters)?

b)
Aim: To design IIR Chebyshew type I high pass filter.
Program:
%Design of IIR Chebyshew type I high pass filter
fp=input ('enter the pass band frequency=');
omp=2*fp/F;
oms=2*fs/F;
[n, wn]=cheb1ord (omp, oms, alphap, alphas) [b,
a]=cheby1 (n, wn, high)
w=0:0.1: pi;
m=20*log (abs (h));
an=angle (h);
subplot (2, 1, 1);
plot (ph/pi, m);
grid on;
title (‘FREQUENCY RESPONSE OF CHEBYSHEW TYPE I HIGH PASS FILTER’);
subplot (2, 1, 2);
plot (ph/pi, an);
grid on;
title (‘PHASE RESPONSE OF CHEBYSHEW TYPE I HIGH PASS FILTER’);
Output:
enter the pass band attenuation=
enter the stop band attenuation=
enter the passband frequency=
enter the stop band frequency=
n =
Wn =

b =
a =
Result:
Inference: The transition band is less in Chebyshev filter compared to Butterworth
filter.
Questions & Answers
1. What are the parameters that can be obtained from the Chebyshev filter
specifications?
2. Distinguish between Butterworth and Chebyshev (type-I) filter?

6. N-POINT FFT ALGORITHM
Aim: To determine the N-point FFT of a given sequence.
Theory: The Fast Fourier transform is a highly efficient procedure for computing
the DFT of a finite series and requires less no of computations than that of direct
evaluation of DFT. It reduces the computations by taking the advantage of the fact
that the calculation of the coefficients of the DFT can be carried out iteratively. Due to
this, FFT computation technique is used in digital spectral analysis, filter simulation,
autocorrelation and pattern recognition. The FFT is based on decomposition and
breaking the transform into smaller transforms and combining them to get the total
transform. FFT reduces the computation time required to compute a discrete Fourier
transform and improves the performance by a factor 100 or more over direct
evaluation of the DFT. The fast fourier transform algorithms exploit the two basic
properties of the twiddle factor
k + N
k + N / 2
(symmetry property: w N
k
= −w k
N ,
periodicity property:
w
N
= w
N
) and reduces the number of complex
multiplications required to perform DFT from N
2
to N/2 log2N. In other words, for
N=1024, this implies about 5000 instead of 106
multiplications - a reduction factor of
200. FFT algorithms are based on the fundamental principal of decomposing the
computation of discrete fourier transform of a sequence of length N into successively
smaller discrete fourier transform of a sequence of length N into successively smaller
discrete fourier transforms. There are basically two classes of FFT algorithms. They
are decimation-in-time and decimation-in-frequency. In decimation-in-time, the
sequence for which we need the DFT is successively divided into smaller sequences
and the DFTs of these subsequences are combined in a certain pattern to obtain the
required DFT of the entire sequence. In the decimation-in-frequency approach, the
frequency samples of the DFT are decomposed into smaller and smaller
subsequences in a similar manner.
Radix - 2 DIT - FFT algorithm
1. The number of input samples N=2M
, where, M is an integer.
2. The input sequence is shuffled through bit-reversal.
3. The number of stages in the flow graph is given by M=log2 N.
4. Each stage consists of N/2 butterflies.

5. Inputs/outputs for each butterfly are separated by 2m-1
samples, where m
represents the stage index, i.e., for first stage m=1 and for second stage m=2
so on.
6. The no of complex multiplications is given by N/2 log2 N.
7. The no of complex additions is given by N log2 N.
8. The twiddle factor exponents are a function of the stage index m and is given
by k =
Nt
m
t = 0,1,2,...2 m−1
−1.
2
9. The no of sets or sections of butterflies in each stage is given by the formula
2M-m.
10. The exponent repeat factor (ERF), which is the number of times the exponent
sequence associated with m is repeated is given by 2M-m.
Radix - 2 DIF - FFT Algorithm
, where M is number of stages.
2. The input sequence is in natural order.
5. Inputs/outputs for each butterfly are separated by 2M-m
samples, Where m
represents the stage index i.e., for first stage m=1 and for second stage m=2
so on.
6. The number of complex multiplications is given by N/2 log2 N.
7. The number of complex additions is given by N log2 N.
by k =
2
N t
M −m
+1
m−m
,t = 0,1,2,...2 −1.
9. The number of sets or sections of butterflies in each stage is given by the
formula 2m-1.
10. The exponent repeat factor (ERF), which is the number of times the
exponent sequence associated with m repeated is given by 2m-1
.
For decimation-in-time (DIT), the input is bit-reversed while the output is in natural order.
Whereas, for decimation-in-frequency the input is in natural order while the output is bit
reversed order.
The DFT butterfly is slightly different from the DIT wherein DIF the complex
multiplication takes place after the add-subtract operation.

Both algorithms require N log2 N operations to compute the DFT. Both algorithms
can be done in-place and both need to perform bit reversal at some place during the
computation.
Program:
% N-point FFT algorithm
N=input ('enter N value=');
Xn=input ('type input sequence=');
k=0:1: N-1;
L=length (xn)
if (N<L)
error ('N MUST BE>=L');
end;
x1= [xn zeros (1, N-L)] for
c=0:1:N-1;
for n=0:1:N-1;
p=exp (-i*2*pi*n*C/N);
x2(c+1, n+1) =p;
end;
Xk=x1*x2';
end;
MagXk=abs (Xk);
angXk=angle (Xk);
subplot (2, 1, 1);
stem (k, magXk);
title ('MAGNITUDE OF DFT SAMPLES');
xlabel ('---->k');
ylabel ('-->Amplitude');
subplot (2, 1, 2);
stem (k, angXk);
title ('PHASE OF DFT SAMPLES');
xlabel ('---->k');
ylabel ('-->Phase');
disp (‘abs (Xk) =');
disp (magXk)
disp ('angle=');
disp (angXk)

Output:
enter N value=
type input sequence=
L=
x1 =
abs (Xk) =
angle=
Result:
Inference: FFT reduces the computation time required to compute discrete
Fourier transform
Questions & Answers
1. What are the applications of FFT algorithms?
2. What is meant by radix-2 FFT?
3. What is an FFT "radix"?
4. What are "twiddle factors"?
5. What is an "in place" FFT?
6. What is "bit reversal"?
7. What is "decimation in time" versus "decimation in frequency"?

7. MATLAB PROGRAM TO GENERATE SUM OF SINUSOIDAL
SIGNALS
Aim: To generate sum of sinusoidal signals.
Theory:
Sinusoidal sequence:
X (n) = cos (w0n +θ ), ∀n
Where θ is the phase in radians. A MATLAB function cos (or sin) is used to
generate sinusoidal sequences.
Signal addition: This is a sample-by-sample addition given by
{X1 (n)} + {x2(n)} = {x1(n) + x2(n)}
It is implemented in Matlab by the arithmetic operator ‘’+’’. However, the lengths of
x1 (n) and x2 (n) must be the same. If sequences are of unequal lengths, or if the
sample positions are different for equal length sequences, then we cannot directly
use the operator + . We have to first augment x1 (n) and x2 (n) so that they have the
same position vector n (and hence the same length). This requires careful attention
to MATLab’s indexing operations. In particular, logical operation of intersection ‘’&’’
relational operations like ‘’<=’’ and ‘’==’’ and the find function are required to make
x1(n) amd x2 (n) of equal length.
Program:
%Generation of sum of sinusoidal sequences n=-
4:0.5:4;
y1=sin (n)
subplot (2, 2, 1)
stem (n, y1,'filled')
grid on;
xlabel ('-->Samples');
ylabel ('--->Magnitude');
title ('SINUSOIDAL SIGNAL1');
y2=sin (2*n)
subplot (2, 2, 2)
stem (n, y2,'filled')
grid on;

title ('SINUSOIDAL SIGNAL2');
y3=y1+y2
subplot (2, 1, 2);
stem (n, y3,'filled');
title ('SUM OF SINUSOIDAL SIGNALS');
Output:
Result:
Inference: The lengths of x1 (n) and x2 (n) must be the same for sample-by-
sample addition.
Questions & Answers
1. What is deterministic signal? Give example.
2. Define a periodic signal?

8. MATLAB PROGRAM TO FIND FREQUENCY RESPONSE OF
ANALOG LP/HP FILTERS.
a)
Aim: To find frequency response of Butterworth analog low pass filter.
Theory: The magnitude function of the butterworth lowpass filter is given by
H( jΩ) =1/[1+ (Ω/Ωc
2N 1/2
) ] N = 1, 2, 3,
Where N is the order of the filter and Ωc is the cutoff frequency.
The following expression is used for the order of the filter.
log
N =
10
10
log
0.1α S
− 1
0.1α P
− 1
Ω S
Ω P
Two properties of Butterworth lowpass filter
1. The magnitude response of the butterworth filter decreases
monotonically as the frequency Ω increases from 0 to ∞.
2. The magnitude response of the butterworth filter closely approximates
the ideal response as the order N increases.
3. The poles of the Butterworth filter lies on a circle.
Steps to design an analog butterworth lowpass filter
1. From the given specifications find the order of the filter N.
2. Round off it to the next higher integer.
3. Find the transfer function H (s) for Ωc = 1 rad/sec for the value of N.
4. Calculate the value of cutoff frequency Ωc.
5. Find the transfer function Ha (s) for the above value of Ωc by substituting
s s/Ωc in H(s).
Program:
%Design of Butterworth lowpass filter
fp=input ('enter the passband frequency=');
omp=2*fp/F;

oms=2*fs/F;
[N, wn]=buttord (omp, oms, alphap, alphas,'s') [b,
a]=butter (n, wn)
w=0:0.01: pi;
m=20*log (abs (h));
an=angle (h);
subplot (2, 1, 1);
plot (ph/pi, m);
grid on;
xlabel ('Normalised Frquency');
title ('FREQUENCY RESPONSE OF BUTTERWORTH LOWPASS FILTER');
subplot (2, 1, 2);
plot (ph/pi, an);
grid on;
xlabel ('Normalisd Frequency');
title ('PHASE RESPONSE OF BUTTERWORTH LOWPASS FILTER');
Output:
Enter the sampling frequency=
n =
Wn =
b =
a =

Result:
Inference: The magnitude response of the butterworth filter decreases
monotonically as the frequency increases.
Questions & Answers
1. Give any two properties of Butterworth lowpass filters?
b)
Aim: To find frequency response of Chebyshew type I analog high pass Filter.
Theory: There are two types of Chebyshev filters. Type I Chebyshev filters are allpole
filters that exhibits equiripple behaviour in the passband and a monotonic
characteristics in the stopband. On the other hand, the family of type II Chebyshev filter
contains both poles and zeros and exhibits a monotonic behaviour in the passband
and equiripple behaviour in the stopband.
The magnitude square response of Nth
order type I filter can be expressed as
|H(jΩ) |2
= 1/1+є2
C2N
[Ω/Ωp] N = 1, 2,----
Where є is a parameter of the filter related to the ripple in the passband and CN (x) is the Nth
order Chebyshev polynomial defined as
CN (x) = cos (N cos-1
x), |x| ≤ 1 (passband)
And
CN (x) = cosh (N cosh-1
x), |x| > 1 (stopband)
Steps to design an analog Chebyshev lowpass filter
1. From the given specifications find the order of the filter N.
2. Round off it to the next higher integer.

3. Using the following formulas find the value of a and b, which are minor and
major axis of the ellipse respectively.
a = Ωp [µ1/N
- µ-1/N
]
2 ;
b=Ωp [µ1/N
- µ-1/N]
2
Where µ = є-1
+ є-2
+ 1
Є = 10
0.1
α
p - 1
Ωp = passband frequency
α
p
=
Maximum allowable attenuation in the passband
(For normalized Chebyshev filter Ωp = 1 rad/sec)
4. Calculate the poles of Chebyshev filter which lies on an ellipse by using the
formula.
Sk = a cosФk + jb sin Фk k= 1, 2, .N
Where Фk = Π /2 + [2k-1/2N] Π k= 1, 2, .N
5. Find the denominator polynominal of the transfer function using above poles.
6. The numerator of the transfer function depends on the value of N.
a) For N odd substitute s = 0 in the denominator polynominal and find
the value. This value is equal to the numerator of the transfer
function.
(For N odd the magnitude response |H(jΩ)| starts at 1.)
b) For N even substitute s=0 in the denominator polynominal and divide
the result by 1+ Є2
. This value is equal to the numerator.
The order N of Chebyshev filter is given by
N= cos h-1
[(100.1
α
α
s -1)/ (100.1
p -1)]/cos h-1
( Ωs/
Ωp
)
Ω s and α p
Where α s is stopband attenuation at stopband frequency is passband
attenuation at passband frequency Ωp
. The major minor axis of the ellipse is given
by
b= Ωp
[(µ1/N
+ µ-1/N
)/2] and a =
Ω
p [ (µ1/N
- µ-1/N
)/2]
Where µ = Є-1
+ 1+ Є-2

And Є =(10
0.1
α
p
-1)
Program:
%Design of IIR Chebyshew type I high pass filter
wp=input ('enter the pass band frequency=');
ws=input ('enter the stop band frequency=');
[n, wn]=cheb1ord (wp/pi, ws/pi, alphap, alphas,'s')
[b, a]=cheby1 (n, alphap, wn,'high')
w=0:0.01: pi;
m=20*log (abs (h));
an=angle (h);
subplot (2, 1, 1);
plot (ph/pi, m);
grid on;
xlabel ('Normalised Frquency');
title ('FREQUENCY RESPONSE OF CHEBYSHEW TYPE I HIGHPASS
FILTER');
subplot (2, 1, 2);
plot (ph/pi, an);
grid on;
xlabel ('Normalisd Frequency');
title ('PHASE RESPONSE OF CHEBYSHEW TYPE I HIGHPASS FILTER');

Output:
n =
wn =
b =
a =
Result:
Inference: Chebyshev approximation provides better characteristics near the
cutoff frequency and near the stop band edge.
Questions & Answers
1. How one can design digital filters from analog filters?
2. What are the properties of Chebyshev filter?

9. POWER DENSITY SPECTRUM OF A SEQUENCE
Aim: To compute power density spectrum of a sequence.
Theory: PSD Power Spectral Density estimate.
Pxx = PSD(X, NFFT, Fs, WINDOW) estimates the Power Spectral Density of
a discrete-time signal vector X using Welch's averaged, modifiedperiodogram
method.X is divided into overlapping sections, each of which is detrended (according
to the detrending flag, if specified), then windowed by the WINDOW parameter, then
zero-padded to length NFFT. The magnitude squared of the length NFFT DFTs of
the sections are averaged to form Pxx. Pxx is length NFFT/2+1 for NFFT even,
(NFFT+1)/2 for NFFT odd, or NFFT if the signal X is complex. If you specify a scalar
for WINDOW, a Hanning window of that length is used. Fs is the sampling frequency
which doesn't affect the spectrum estimate but is used for scaling the X-axis of the
plots. [Pxx, F] = PSD(X, NFFT, Fs, WINDOW, NOVERLAP) returns a vector of
frequencies the same size as Pxx at which the PSD is estimated, and overlaps
the sections of X by NOVERLAP samples. [Pxx, Pxxc, F] = PSD(X, NFFT, Fs,
WINDOW, NOVERLAP, P) where P is a scalar between 0 and 1, returns the P*100%
confidence interval for Pxx. PSD(X, DFLAG), where DFLAG can be 'linear', 'mean' or
'none', specifies a detrending mode for the prewindowed sections of X. DFLAG can
take the place of any parameter in the parameter list (besides X) as long as it is last,
e.g. PSD(X,'mean'); PSD with no output arguments plots the PSD in the current
figure window, with confidence intervals if you provide the P parameter. The default
values for the parameters are NFFT = 256 (or LENGTH(X), whichever is smaller),
NOVERLAP = 0, WINDOW = HANNING (NFFT), Fs = 2, P = .95, and DFLAG =
'none'. You can obtain a default parameter by leaving it off or inserting an empty
matrix [], e.g. PSD(X, [], 10000).
Program:
%Power density spectrum of a sequence
x=input ('enter the length of the sequence=');
y=input ('enter the sequence=');
fs=input ('enter sampling frequency=');
N=input ('enter the value of N=');
q=input ('enter the window name1=');
m=input ('enter the window name2=');
s=input ('enter the window name3=');
pxx1=psd(y, N, fs, q)

plot (pxx1,'c');
hold on;
grid on;
pxx2=psd(y, N, fs, m)
plot (pxx2,'k');
hold on;
pxx3=psd(y, N, fs, s)
plot (pxx3,'b');
hold on;
xlabel ('-->Frequency');
ylabel ('-->Magnitude');
title ('POWER SPECTRAL DENSITY OF A SEQUENCE');
hold off;
Output:
Enter the length of the sequence=
Enter the sequence=
Enter sampling frequency=
Enter the value of N=
Enter the window name1=
pxx1 =
pxx2 =
pxx3 =

Result:
Inference: Power spectral density does not have any phase information.
Questions & Answers
1. Define power spectral density?
2. What is window function? What are the applications of window functions?

10. FFT OF A GIVEN 1-D SIGNAL
Aim: To find the FFT of a given 1-D signal and plot the characteristics.
Theory: The DFT of a sequence can be evaluated using the formula
N−1
X(k) = x(n)e
n =0
Substituting WN =
e
−j
2
π /N , we have
N−1
− j2πnk / N
0 ≤ k ≤N -1
nk
X(k) = x(n)WN
0 ≤ k ≤N - 1
n=0
The Fast Fourier transform is a highly efficient procedure for computing the DFT of a
finite series and requires less no of computations than that of direct evaluation of
DFT. It reduces the computations by taking the advantage of the fact that the
calculation of the coefficients of the DFT can be carried out iteratively. Due to this,
FFT computation technique is used in digital spectral analysis, filter simulation,
autocorrelation and pattern recognition. The FFT is based on decomposition and
breaking the transform into smaller transforms and combining them to get the total
transform. FFT reduces the computation time required to compute a discrete Fourier
transform and improves the performance by a factor 100 or more over direct
evaluation of the DFT. The fast fourier transform algorithms exploit the two basic
properties of the twiddle factor
k + N
k + N / 2
(symmetry property: w N
k
= −w k
N ,
periodicity property:
w
N
= w
N
) and reduces the number of complex
multiplications required to perform DFT from N
2
to N/2 log2N. In other words, for
N=1024, this implies about 5000 instead of 106
multiplications - a reduction factor of
200. FFT algorithms are based on the fundamental principal of decomposing the
computation of discrete fourier transform of a sequence of length N into successively
smaller discrete fourier transform of a sequence of length N into successively smaller
discrete fourier transforms. There are basically two classes of FFT algorithms. They
are decimation-in-time and decimation-in-frequency. In decimation-in-time, the
sequence for which we need the DFT is successively divided into smaller sequences
and the DFTs of these subsequences are combined in a certain pattern to obtain the
required DFT of the entire sequence. In the decimation-in-frequency approach, the
frequency samples of the DFT are decomposed into smaller and smaller
subsequences in a similar manner.

Radix - 2 DIT - FFT algorithm
, where, M is an integer.
12. The input sequence is shuffled through bit-reversal.
15. Inputs/outputs for each butterfly are separated by 2m-1
samples, where m
represents the stage index, i.e., for first stage m=1 and for second stage m=2
so on.
16. The no of complex multiplications is given by N/2 log2 N.
17. The no of complex additions is given by N log2 N.
by k =
Nt
m
t = 0,1,2,...2 m−1
−1.
2
19. The no of sets or sections of butterflies in each stage is given by the formula
2M-m.
20. The exponent repeat factor (ERF), which is the number of times the exponent
sequence associated with m is repeated is given by 2M-m.
Radix - 2 DIF - FFT Algorithm
, where M is number of stages.
12. The input sequence is in natural order.
15. Inputs/outputs for each butterfly are separated by 2M-m
samples, Where m
represents the stage index i.e., for first stage m=1 and for second stage m=2
so on.
16. The number of complex multiplications is given by N/2 log2 N.
17. The number of complex additions is given by N log2 N.
by k =
2
N t
M −m
+1
m−m
,t = 0,1,2,...2 −1.
19. The number of sets or sections of butterflies in each stage is given by the
formula 2m-1.
20. The exponent repeat factor (ERF),Which is the number of times the exponent
sequence associated with m repeated is given by 2m-1
.

Program:
%To find the FFT of a given 1-D signal and plot
N=input ('enter the length of the sequence=');
M=input ('enter the length of the DFT=');
u=input ('enter the sequence u (n) =');
U=fft (u, M)
A=length (U)
t=0:1: N-1;
subplot (2, 2, 1);
stem (t, u);
title ('ORIGINAL TIME DOMAIN SEQUENCE');
xlabel ('---->n');
subplot (2, 2, 2);
k=0:1:A-1;
stem (k, abs (U));
disp (‘abs (U) =');
disp (abs (U))
title ('MAGNITUDE OF DFT SAMPLES');
xlabel ('---->k');
subplot (2, 1, 2);
stem (k, angle (U));
disp (‘angle (U) =')
disp (angle (U))
title ('PHASE OF DFT SAMPLES');
xlabel ('---->k');
ylabel ('-->phase');

Output:
Enter the length of the DFT=
Enter the sequence u (n) =
U =
A =
abs (U) =
angle (U) =
Result:
Inference: FFT reduces the computation time required to compute discrete
Fourier transform.
Questions & Answers
1. What is the FFT?
2. How does the FFT work?
3. How efficient is the FFT?
4. Are FFT's limited to sizes that are powers of 2?

1. GENERATION OF BASIC SEQUENCES
Aim: To generate impulse, step and sinusoidal sequences.
Program:
%Generation of basic sequences
%generation of impulse sequence
t=-2:1:2;
v= [zeros (1, 2), ones (1, 1), zeros (1, 2)]
subplot (2, 2, 1);
stem (t, v,'m','filled');
grid on;
xlabel ('--->n');
title (' IMPULSE SEQUENCE');
%generation of step sequence
t=0:1:5;
m= [ones (1, 6)]
subplot (2, 2, 2);
stem (t, m,'m','filled');
grid on;
xlabel ('--->n');
title (' STEP SEQUENCE');
%generation of sinusoidal sequence
t=-4:1:4;
y=sin (t)
subplot (2, 1, 2);
stem (t, y,'m','filled');
grid on;
xlabel ('--->n');
title ('SINUSOIDAL SEQUENCE');

2. DFT OF A SEQUENCE
Aim: To compute the DFT of a sequence.
Program:
%DFT of a sequence
N=input ('enter the length of the sequence=');
x=input ('enter the sequence=');
n= [0:1: N-1];
k= [0:1: N-1];
wN=exp (-j*2*pi/N);
nk=n'*k;
wNnk=wN. ^nk;
Xk=x*wNnk;
disp ('Xk=');
disp (Xk);
mag=abs (Xk)
subplot (2, 1, 1);
stem(k,mag);
grid on;
xlabel('--->k');
title ('MAGNITUDE OF FOURIER TRANSFORM');
ylabel ('Magnitude');
phase=angle (Xk)
subplot (2, 1, 2);
stem (k, phase);
grid on;
xlabel ('--->k');
title ('PHASE OF FOURIER TRANSFORM');
ylabel ('Phase');

Output:
Enter the sequence=
Xk=
mag =
phase =
Result:

3. IDFT OF A SEQUENCE
Aim: To compute the IDFT of a sequence.
Program:
%IDFT of a sequence
Xk=input (‘enter X (K) ='); [N,
M]=size (Xk);
if M~=1;
Xk=Xk.';
N=M;
end;
xn=zeros (N, 1);
k=0: N-1;
for n=0: N-1;
xn (n+1) =exp (j*2*pi*k*n/N)*Xk;
end;
xn=xn/N;
disp (‘x (n) = ');
disp (xn);
plot (xn);
grid on;
plot(xn);
stem(k,xn);
xlabel ('--->n');
ylabel ('-->magnitude');
title (‘IDFT OF A SEQUENCE’);
Output:
Enter the dft of X (K) =
x (n) =
Result:

TEXAS INSTRUMENT DSP STARTER KIT 6711DSK
A BRIEF INTRODUCTION
1 Introduction
The purpose of this documentation is to give a very brief overview of the structure of the
6711DSK. Included is also a mini tutorial on how to program the DSP, download programs
and debug it using the Code Composer Studio software.
2 The DSP starter kit
The Texas Instrument 6711DSK is a DSP starter kit for the TMS320C6711 DSP chip. The kit
contains:
• An emulator board which contains:
- DSP chip, memory and control circuitry.
- Input/output capabilities in the form of
_ An audio codec (ADC and DAC) which provides 1 input and 1 output
channel sampled at 8 kHz.
_ Digital inputs and outputs
_ A connector for adding external evaluation modules, like the PCM3003
Audio daughter card which has 2 analog in and 2 analog out sampled at
48 kHz.
- A parallel port for interface to a host computer used for program
development, program download and debugging.
• The Code Composer Studio (CCS) software which is an integrated development
environment (IDE) for editing programs, compiling, linking, download to target
(i.e., to the DSK board) and debugging. The CCS also includes the DSP/BIOS
real-time operating system. The DSP/BIOS code considerably simplifies the code
development for real-time applications which include interrupt driven and time
scheduled tasks.

3 Usage overview
Working with the DSK involves the following steps:
• The first step is the algorithm development and programming in C/C++ or
assembler. We will only consider coding in C in this document. The program is typed using
the editor capabilities of the CCS. Also the DSP/BIOS configuration is performed in a
special configuration window.
• When the code is finished it is time to compile and link the different code parts
together. This is all done automatically in CCS after pressing the Build button. If
the compilation and linking succeeded the finished program is downloaded to the
DSK board.
• The operation of DSK board can be controlled using CCS, i.e., CCS also works as a
debugger. The program can be started and stopped and single-step. Variables in the
program can be inspected with the “Watch” functionality. Breakpoints can be inserted in
the code.
4 Getting started with the 6711DSK and CCS
In this section you will be introduced to the programming environment and will
download and execute a simple program on the DSK.
4.1 Connecting the PC and DSK
The DSK is communicating with the host PC using the parallel-port interface.
1. Start Code Composer Studio (CCS) by clicking on the “CCStudio 3.01” icon on the
workspace.
2. Check that the DSK is powered up. If not, power up the DSK by inserting the AC
power cable (mains) to the black AC/DC converter. Note: Never unplug the power
cable from the DSK card.
3. Make a connection between CCS and the DSK by selecting menu command
Debug! Connect. If connection fails perform following steps:
(a) Select menu command Debug! Reset Emulator
(b) Power cycle the DSK by removing the AC power cord from the AC/DC converter, wait
about a second and then reinsert.
(c) Select menu command Debug! Connect.

4.2 Getting familiar with CCS
CCS arranges its operation around a project and the “Project view” window is
displayed to the left. Here you can find all files which are related to a certain project. At the
bottom of the CCS window is the status output view in which status information will be
displayed such as compile or link errors as well as other types of information. Note that the
window will have several tabs for different types of output.
4.3 Loading programs from CCS
One setting might need to be changed in CCS in order to automatically download the
program after compilation and linking (a build). You find the setting under menu
command Options! Customize and tab Program Load Options. Tick the box Load
Program after Build.
4.3.1 Project view and building an application
You open an existing project by right-clicking on the project folder and select the
desired “.pjt” file or select the command from the menu Project! Open.............
• Open the project “intro.pjt” which you find in the “intro”folder.
• Press the “+” sign to expand the view. Several folders appear which contain all the
project specific files.
• Open up the Source folder. Here you will find all the files with source code which
belongs to the project.
• Double click on the “intro.c” file to open up an editor window with the file “intro.c” file
loaded.
• Look around in the file. The code calculates the inner product between two integer
vectors of length “COUNT” by calling the function “dotp” and then prints the result using
the “LOG printf” command.
• Compile, link and download the code selecting the Project! Build command or use
the associated button. If the download fails. Power cycle the DSK and retry Project!
Build.

4.3.2 Running the code after a successful build command (compile, link and
download) the program is now resident in the DSK and ready for execution. A
disassembly window will appear showing the Assembly language instructions
produced by the compiler. You can minimize the window for now. At the bottom left
you will see the status “CPU HALTED” indicating that the CPU is not executing any
code. A few options are available depending on if you want to debug or just run the
code.
To simply run the code does:
• Select Debug! Run to start the execution. At the bottom left you will see the status “CPU
RUNNING” indicating that the program is executed.
• To stop the DSP select Debug! Halt.
• If you want the restart the program do Debug! Restart followed by Debug! Run
Try to run the code in the intro project. To see the output from the LOG printf
commands you must enable the view of the Message Log Window. Do DSP/BIOS!
Message Log and select LOG0 in the pull-down menu.
4.3.3 CCS Debug
Single stepping for debugging the code do the following:
• Select Debug! Go Main. This will run DSP/BIOS part of the code until the start
of the “main” function. A yellow arrow will appear to the left of the start of the
“main” function in the edit window for the “intro.c” file. The arrow indicates where
the program execution has halted.
• Now you can step the code one line at the time. Three commands are available:
- Debug! Step Into will execute the marked line if it is composed of simple
instructions or if the line has a function call, will step in to the called function.
- Debug! Step Over will execute the marked line and step to the next line.

- Debug! Step Out will conclude the execution of the present function and halt
the execution at the next line of the calling function. Try to step through the code
using the step functions. View variables if you want to know the value of a particular
variable just put the cursor on top of the variable in the source window. The value will
after a short delay pop up next to the variable. Note that local variables in functions
only have defined values when the execution is located inside the function. Variables
can also be added to the “Watch window” which enables a concurrent view of several
variables. Mark the “y” variable in source code, right-click and select Add to Watch
Window. The watch window
will then add variable “y” to the view and show its contents. Also add the “a” variable (which
is a array) to the watch window. Since “a” is an array the value of “a” is an address. Click
on the “+”. This will show the individual values of the array. The watch window will update
its contents whenever the DSP is halted. It is also possible to change the value of a
variable in the DSK from the Watch window. Simply select the numerical value you want to
change and type in a new value. CCS will send the new value to the DSK before starting the
execution.
Break points Break points can also be used to halt the execution at a particular point
in the source code. To illustrate its use consider the “intro”. Place the cursor at the
line which has the “return (sum);” instruction in the “dotp” function. Right-click and
select Toggle breakpoint. A red dot will appear at that line indicating that a breakpoint
is set at that line. Try it out. First do Debug! Restart and then Debug! Run The
execution will halt at the line and we can investigate variables etc. To resume
execution simply issue Debug! Run command again. Shortcut buttons CCS offers a
number of shortcut buttons both for the build process as well as the debugging.
Browse around with the mouse pointer to find them. The balloon help function will
show what command a particular button is associated with, i.e., move the mouse
pointer over a button and wait for the balloon help to show up. Loading the values in
a vector into Matlab In the Lab you will need to load the coefficients of a FIR filter into
Matlab for further analysis. The filter coefficients are stored in vectors. Use the
following procedure:
1. Run the DSP program on the DSK.
2. Halt the execution when it is time to upload the vector.
3. In the File menu you find File! Data! Save In the file dialog assign a name to the
data file and select ”Float” as ”Save as type”.

4. In the next dialog enter the name of the vector in the address field. When you tab away
from it it will change to the absolute memory address of the vector. In the length box
you enter the length of the variable. Note that you need to remove the 0x prefix if you give
the length using decimals numbers. The notation with 0x in the beginning indicates
that the number is a Hexadecimal number, i.e. it is based on a base of 16 instead of the
normal base of 10 in the decimal system.
5. Open the file in an editor and remove the first line and save again
6. In Matlab use the ”load” command to load the saved file. The vector will get the same
name as the file name without the extension.
5 Debugging - limitations
The debugging features of the CCS are very handy during the code development.
However, several limitations are present.
• Since the compiler will optimize the code, all lines in the C-code cannot be used as
breakpoints. Since the architecture has several parallel processing units the final code
might execute several lines of C in one clock cycle.
• The processor also has memory cache which speeds up normal operations. This
means that when the DSP loads a particular memory location it will copy it into
the cache memory and then perform the operations (faster) using the cache. After some
time the cache will be written back again to the memory. This can sometimes confuse CCS
and variables in the Watch window can be erroneous.
• The third important issue is when debugging code which is dependent on external
events, e.g., interrupt driven code. When halting such a code by a break point
several features are important to consider. Firstly, since the code is stopped all realtime
deadlines will be broken so future sampled inputs will be lost. Hence a restart from the
point of the break might cause unpredicted behavior.
• Sometimes the code in the DSK which communicates with the CCS stops working.
When this happens it is necessary to power cycle, the DSK board in order to restart
the operation. Sometimes it is also necessary at the same time to restart CCS.

PROCEDURE TO WORK ON CODE COMPOSER
STUDIO
To create the new project
Project new (File name.pjt, eg: vectors.pjt)
To create a source file
File new type the code (save &give file name, eg: sum.c
To add source files to project
Project add files to project sum.c
To add rts.lib file&hello.cmd:
Project add files to project rts6700.lib
Libraryfiles: rts6700.lib (path:c:tic6000cgtoolslibrts6700.lib) Note:
select object&library in (*.o,*.1) in type of files
Project add files to projects hello.cmd
Cmd file - which is common for all non real time programs.
(path:ctitutorialsdsk6711hello.1hello.cmd)
Note: select linker command file (*.cmd) in type of files
Compile:
To compile: project compile
To rebuild: project rebuild
Which will create the final.outexecutablefile (eg.vectors.out)
Procedure to load and run program:
Load the program to DSK: file load program vectors. Out To
execute project: Debug run

C PROGRAMS
(USING64XX, 67XX SIMULATORS)

Aim: Write a C program for linear convolution of two discrete sequences and
compute using code composer studio V2 (using simulators 64xx, 67xx, 6711)
software.
Program:
#include<stdio.h>
#include<math.h>
main ()
{
int x[20],h[20],y[20],N1,N2,n,m;
printf ("enter the length of the sequence x (n) :");
scanf ("%d", &N1);
printf ("enter the length of the sequence h (n) :");
scanf ("%d", &N2);
printf ("enter the sequence x (n) :"); for
(n=0; n<N1; n++)
scanf ("%d", &x[n]);
printf ("enter the sequence h (n) :"); for
(n=0; n<N2; n++)
scanf ("%d", &h[n]);
for (n=0; n<N1+N2-1; n++)
{
if (n>N1-1)
{
y[n]=0;
for(m=n-(N1-1);m<=(N1-1);m++) y[n]
=y[n] +x[m]*h [n-m];
}
else
{
y[n] =0;
for (m=0; m<=n; m++)
y[n] =y[n] +x[m]*h [n-m];
}
}
printf ("convolution of two sequences is y (n) :"); for
(n=0; n<N1+N2-1; n++)
printf ("%dt", y[n]);
}

Input:
Enter the length of the sequence x (n):
Enter the length of the sequence h (n):
Enter the sequence x (n):
Enter the sequence h (n):
Output:
Convolution of two sequences is y (n):
Result:

Aim: Write a C program for circular convolution of two discrete sequences and
compute using code composer studio V2 (using simulators 64xx, 67xx, 6711)
software.
Program:
#include<math.h>
#define pi 3.14
main ()
{
int x[20],h[20],y[20],N1,N2,N,n,m,k;
scanf ("%d", &N1);
scanf ("%d", &N2);
printf ("enter the %d samples of sequence x (n):” N1); for
(n=0; n<N1; n++)
printf ("enter the %d samples of sequence h (n):” N2); for
(n=0; n<N2; n++)
scanf ("%d", &h[n]); if
(N1>N2)
{
N=N1;
for (n=N2; n<N; n++)
h[n]=0;
}
else
{
N=N2;
for(n=N1;n<N1;n++)
y[n]=0;
}

for(k=0;k<N;k++)
{
y[k]=0;
for (m=N-1; m>=0; m--)
{
if ((N+k-m)>=N)
{
y[k] =y[k] +x[m]*h [k-m];
}
else
y[k] =y[k] +x[m]*h [N+k-m];
}
}
printf ("response is y (n) :"); for
(n=0; n<N; n++)
printf ("t%d", y[n]);
}
Input:
Enter the 4 samples of sequence x (n):
Enter the 4 samples of sequence h (n):
Output:
Response is y (n):
Result:

3. DFT OF A SEQUENCE
Aim: Write a C program for DFT of a sequence and compute using code composer studio
V2 (using simulators 64xx, 67xx, 6711) software.
Program:
%DISCRETE FOURIER TRANSFORM OF THE GIVEN SEQUENCE
#include<stdio.h>
#include<math.h>
#define pi 3.14
main ()
{
int x [20], N, n, k;
float Xre[20],Xim[20],Msx[20],Psx[20];
scanf ("%d", &N);
printf ("enter the %d samples of discrete sequence x (n):” N); for
(n=0; n<N; n++)
for(k=0;k<N;k++)
{
Xre[k]=0;
Xim[k]=0;
for(n=0;n<N;n++)
{
Xre[k]=Xre[k]+x[n]*cos(2*pi*n*k/N);
Xim[k]=Xim[k]+x[n]*sin(2*pi*n*k/N); }
Msx[k]=sqrt(Xre[k]*Xre[k]+Xim[k]*Xim[k]);
Xim[k]=-Xim[k];
Psx[k]=atan(Xim[k]/Xre[k]);
}
printf ("discrete sequence is");
for (n=0; n<N; n++)

printf ("nx(%d) =%d", n,x[n]);
printf ("nDFT sequence is :");
for(k=0;k<N;k++)
printf("nx(%d)=%f+i%f",k,Xre[k],Xim[k]);
printf("nmagnitude is:");
for (k=0; k<N; k++)
printf ("n%f",Msx[k]);
printf ("nphase spectrum is");
for(k=0;k<n;k++)
printf("n%f",Psx[k]);
}
Input:
Enter the 4 samples of discrete sequence x (n):
Output:
Discrete sequence is:
x (0) =
x(1) =
x(2) =
x (3) =
DFT sequence is :
x(0)=
x(1)=
x(2)=
x (3) =
Magnitude is: Phase spectrum is:
Result:

4. IDFT OF A SEQUENCE
Aim: Write a C program for IDFT of a sequence and compute using code composer studio
V2 (using simulators 64xx, 67xx, 6711) software.
Program:
% Inverse Discrete Foureir Transform
#include<stdio.h>
#include<math.h>
#define pi 3.1428
main()
{
int j, k, N, n;
float XKr[10],XKi[10],xni[10],xnr[10],t;
printf (" enter seq length: n");
scanf ("%d", &N);
printf ("enter the real & imaginary terms of the sequence: n"); for
(j=0; j<N; j++)
{
scanf ("%f%f", &XKr[j], &XKi[j]);
}
for (n=0; n<N; n++)
{
xnr[n] =0; xni[n] =0;
for(k=0;k<N;k++)
{
t=2*pi*k*n/N;
xnr[n]=( xnr[n]+XKr[k]*cos(t) - XKi[k]*sin(t)) ;
xni[n]=( xni[n]+XKr[k]*sin(t) + XKi[k]*cos(t)) ;
}
xnr[n]=xnr[n]/N;
xni[n]=xni[n]/N;
}
printf("IDFT seq:");
for(j=0;j<N;j++)

{
printf("%f + (%f) in",xnr[j],xni[j]);
}
}
Input:
Enter seq length:
Enter the real & imaginary terms of the sequence:
Output:
IDFT seq:
Result:

5. N - POINT DISCRETE FOUREIR TRANSFORM
Aim: Write a C program for N - Point Discrete Foureir Transform of a sequence
and compute using code composer studio V2( using simulators 64xx,67xx,6711)
software.
Program:
% N - Point Discrete Foureir Transform
#include<stdio.h>
#include<math.h>
#define pi 3.142857
main ()
{
int j, k, n, N, l;
scanf ("%d", &l);
(j=0; j<l; j++)
{
scanf ("%f%f", &xnr[j], &xni[j]);
}
printf (" enter required length: n");
scanf ("%d", &N);
if (l<N)
{
for(j=l;j<N;j++)
xnr[j]=xni[j]=0;
}
for(k=0;k<N;k++)
{
XKr[k]=0; XKi[k]=0;
for(n=0;n<N;n++)
{
t=2*pi*k*n/N;

XKr[k]=( XKr[k]+xnr[n]*cos(t) + xni[n]*sin(t)) ;
XKi[k]=( XKi[k]+ xni[n]*cos(t) - xnr[n]*sin(t)) ;
}
}
printf (" The %d Point DFT seq:” N);
for(j=0;j<N;j++)
{
printf("%3.3f + (%3.3f) in",XKr[j],XKi[j]);
}
}
Input:
Enter seq length:
enter required length:
Out put:
The 4 Point DFT seq:
Result:

6. TO GENERATE SUM OF SINUSOIDAL SIGNALS
Aim: Write a C program to generate sum of sinusoidal signals and compute using code
composer studio V2 (using simulators 64xx, 67xx, 6711) software.
Program:
%SUM OF TWO SINUSOIDALS
#include<stdio.h>
#include<math.h>
main ()
{
int w1, w2, t;
float a, b, c;
printf ("enter the w1 value:");
scanf ("%d", &w1);
printf ("enter the w2 value:");
scanf ("%d", &w2);
printf ("sum of two sinusoidal :");
for(t=-5;t<5;t++)
{
b=sin(w1*t);
c=sin (w2*t);
a=b+c;
printf ("n%f", a);
}
}

Input:
Enter the w1 value:
Enter the w2 value:
Output:
Sum of two sinusoidal:
Result:

PROGRAMS USING TMS 320C 6711 DSK

Aim: Write a C program for linear convolution of two discrete sequences and
compute using TMS 320C 6711 DSK.
Program:
#include<stdio.h>
#include<math.h>
main ()
{
int x[20],h[20],y[20],N1,N2,n,m;
scanf ("%d", &N1);
scanf ("%d", &N2);
printf ("enter the sequence x (n) :"); for
(n=0; n<N1; n++)
printf ("enter the sequence h (n) :"); for
(n=0; n<N2; n++)
scanf ("%d", &h[n]);
for (n=0; n<N1+N2-1; n++)
{
if (n>N1-1)
{
y[n]=0;
for(m=n-(N1-1);m<=(N1-1);m++) y[n]
=y[n] +x[m]*h [n-m];
}
else
{
y[n] =0;
for (m=0; m<=n; m++)
y[n] =y[n] +x[m]*h [n-m];
}
}
printf ("convolution of two sequences is y (n) :");

for (n=0; n<N1+N2-1; n++)
printf ("%dt", y[n]);
}
Input:
Enter the sequence x (n):
Enter the sequence h (n):
Output:
Convolution of two sequences is y (n):
Result:

Aim: Write a C program for circular convolution of two discrete sequences and
compute using using TMS 320C 6711 DSK.
Program:
#include<math.h>
#define pi 3.14
main ()
{
int x[20],h[20],y[20],N1,N2,N,n,m,k;
scanf ("%d", &N1);
scanf ("%d", &N2);
printf ("enter the %d samples of sequence x (n):", N1); for
(n=0; n<N1; n++)
printf ("enter the %d samples of sequence h (n):” N2); for
(n=0; n<N2; n++)
scanf ("%d", &h[n]); if
(N1>N2)
{
N=N1;
for (n=N2; n<N; n++)
h[n]=0;
}
else
{
N=N2;
for(n=N1;n<N1;n++)
y[n]=0;
}

3. FINDING DFT OF A SEQUENCE
Aim: Write a C program for DFT of a sequence and compute using TMS 320C 6711
DSK.
Program:
%DISCRETE FOURIER TRANSFORM OF THE GIVEN SEQUENCE
#include<stdio.h>
#include<math.h>
#define pi 3.14
main ()
{
int x [20], N, n, k;
float Xre[20],Xim[20],Msx[20],Psx[20];
scanf ("%d", &N);
printf ("enter the %d samples of discrete sequence x (n):” N); for
(n=0; n<N; n++)
for(k=0;k<N;k++)
{
Xre[k]=0;
Xim[k]=0;
for(n=0;n<N;n++)
{
Xre[k]=Xre[k]+x[n]*cos(2*pi*n*k/N);
Xim[k]=Xim[k]+x[n]*sin(2*pi*n*k/N); }
Msx[k]=sqrt(Xre[k]*Xre[k]+Xim[k]*Xim[k]);
Xim[k]=-Xim[k];
Psx[k]=atan(Xim[k]/Xre[k]);
}
printf ("discrete sequence is:");
for (n=0; n<N; n++)
DIGITAL SIGNAL PROCESSING LAB
113

ELECTRONICS & COMMUNICATION ENGINEERING
printf ("nx (%d) =%d", n, x[n]);
printf ("nDFT sequence is :");
for(k=0;k<N;k++)
printf("nx(%d)=%f+i%f",k,Xre[k],Xim[k]);
printf ("nmagnitude is:");
for (k=0; k<N; k++)
printf ("n%f", Msx[k]);
printf ("nphase spectrum is:");
for(k=0;k<n;k++)
printf("n%f",Psx[k]);
}
Input:
Enter the 4 samples of discrete sequence x (n):
Output:
Discrete sequence is:
x (0) =
x(1)=
x(2)=
x (3) =
DFT sequence is :
x(0)=
x(1)=
x(2)=
x (3) =
Magnitude is: Phase spectrum is:
Result:

4. FINDING IDFT OF A SEQUENCE
Aim: Write a C program for IDFT of a sequence and compute using TMS 320C 6711
DSK.
Program:
% Inverse Discrete Foureir Transform
#include<stdio.h>
#include<math.h>
#define pi 3.1428
main ()
{
int j, k, N, n;
scanf ("%d", &N);
printf ("enter the real & imaginary terms of the sequence: n");
for (j=0; j<N; j++)
{
scanf ("%f%f", &XKr[j], &XKi[j]);
}
for (n=0; n<N; n++)
{
xnr[n] =0; xni[n] =0;
for(k=0;k<N;k++)
{
t=2*pi*k*n/N;
xnr[n]=( xnr[n]+XKr[k]*cos(t) - XKi[k]*sin(t)) ;
xni[n]=( xni[n]+XKr[k]*sin(t) + XKi[k]*cos(t)) ;
}
xnr[n]=xnr[n]/N;
xni[n]=xni[n]/N;
}
printf("IDFT seq:");
for(j=0;j<N;j++)
{
printf("%f + (%f) in",xnr[j],xni[j]);
}
}

Input:
Enter seq length:
Output:
IDFT seq:
Result:

5. N - POINT DISCRETE FOUREIR TRANSFORM
Aim: Write a C program for N - Point Discrete Foureir Transform of a sequence and
compute using TMS 320C 6711 DSK.
Program:
% N - Point Discrete Foureir Transform
#include<stdio.h>
#include<math.h>
#define pi 3.142857
main ()
{
int j, k, n, N, l;
scanf ("%d", &l);
(j=0; j<l; j++)
{
scanf ("%f%f", &xnr[j], &xni[j]);
}
Printf (" enter required length: n");
Scanf ("%d", &N);
if (l<N)
{
for(j=l;j<N;j++)
xnr[j]=xni[j]=0;
}
for(k=0;k<N;k++)
{
XKr[k]=0; XKi[k]=0;
for(n=0;n<N;n++)
{

t=2*pi*k*n/N;
XKr[k]=( XKr[k]+xnr[n]*cos(t) + xni[n]*sin(t)) ;
XKi[k]=( XKi[k]+ xni[n]*cos(t) - xnr[n]*sin(t)) ;
}
}
Printf (" The %d Point DFT seq:” N);
for(j=0;j<N;j++)
{
printf("%3.3f + (%3.3f) in",XKr[j],XKi[j]);
}
}
Input:
Enter seq length:
Enter required length:
Out put:
The 4 Point DFT seq:
Result:

6. TO GENERATE SUM OF SINUSOIDAL SIGNALS
Aim: Write a C program to generate sum of sinusoidal signals and compute using TMS
320C 6711 DSK.
Program:
%SUM OF TWO SINUSOIDALS
#include<stdio.h>
#include<math.h>
main ()
{
int w1, w2, t;
float a, b, c;
printf ("enter the w1 value :");
scanf ("%d", &w1);
printf ("enter the w2 value :");
scanf ("%d", &w2);
printf ("sum of two sinusoidal :");
for(t=-5;t<5;t++)
{
b=sin(w1*t);
c=sin (w2*t);
a=b+c;
printf ("n%f", a);
}
}

Dsp manual print

More Related Content

What's hot (20)

Similar to Dsp manual print (20)

Dsp manual print