96

Exp.No:8 Generation of real time signals and implementation of

circular convolution using TMS320C6748 DSP Development
Kit (LCDK).
Aim: To generate real time signals and to implement circular
convolution between any two finite length arbitrary
sequences using TMS320C6748 DSP Development Kit (LCDK).
Apparatus: Computer, TMS320C6748 LCDK Board, Kit connected with 5V
power supply, USB cable connected with PC and JTAG emulator,
XDS100v3 Emulator, Double sided stereo cable and
speakers/earphones (For Filtering), Stereo cables, Function
generator and CRO (For signal filtering applications).
Description:
The low cost TMS320C6748 DSP Development Kit (LCDK) will speed and
ease your hardware development of real-time DSP applications. This
new board reduces design work with freely downloadable and
duplicable board schematics and design files. A wide variety of
standard interfaces for connectivity and storage enable you to
easily bring audio, video and other signals onto the board. This
board is an alternative to the DSK6713 board which has limited
features. This board offers features like image, audio and video
processing on a single board thus offering many on-board features
like camera input interface and VGA features for easy output
interface. You can use the PC monitor as an output device for
display of Image and Video. You do not need and other output
devices like TV. This board can be used for performing more lab
experiments which involves topics like image, and video
processing. This board can be effectively used for performing
hands-on activities and experimentation of DSP hardware. This
board enables the confidence amongst the student to perform the
experiments on the DSP hardware. The TMS320C6748 C6000 DSP
processor is a low-power applications processor based on C674x DSP
core. This processor provides significantly lower power than other
members of the TMS320C6000™ platform of DSPs.
The architecture of the device provides benefits of both DSP and
reduced instruction set computer (RISC) technologies,
incorporating a high-performance TMS320C674x DSP core. The device
DSP core uses a 2-level cache-based architecture. The level 1
program cache (L1P) is a 32- KB direct mapped cache, and the level
1 data cache (L1D) is a 32-KB 2-way, set-associative cache. The
level 2 program cache (L2P) consists of a 256-KB memory space that
 97

is shared between program and data space. L2 memory can be

configured as mapped memory, cache, or combinations of the two.
The LCDK does not have an onboard emulator. An external emulator
from TI (such as the XDS100, XDS200,XDS510, XDS560) or a third-
party will be required to start development.

Fig1: TMS320C6748 LCDK.

 98

Fig2: TMS320C6748 LCDK hardware connections.

Fig3: Connecting Board with XDS100v3 Emulator.

 99

Processor
• TI TMS320C6748 DSP Application Processor.
• 456-MHz C674x Fixed/Floating Point DSP.
• On-Chip RTC.
Memory
• 128 MByte DDR2 SDRAM running at 150MHz.
• 128 MByte 16-bit wide NAND FLASH.
• 1 Micro SD/MMC Slot.

Interfaces
• One mini-USB Serial Port (on-board serial to USB)
• One Fast Ethernet Port (10/100 Mbps) with status LEDs
• One USB Host port (USB 1.1)
• One SATA Port (3Gbps)
• One LCD Port (Beagleboard XM connectors)
• One Leopard Imaging Camera Sensor Input (36-pin ZIP
connector)
• Three AUDIO Ports (1 LINE IN-J55 & 1 LINE OUT-J56 & 1 MIC
IN-J57)
• 14-pin JTAG header (No onboard emulator; external emulator
is required)

TMS320C6748 DSP Features

• Highest-Performance Floating-Point Digital Signal Processor
(DSP):
• Eight 32-Bit Instructions/Cycle
• 32/64-Bit Data Word
• 375/456-MHz C674x Fixed/Floating-Point
• Up to 3648/2746 C674x MIPS/MFLOPS
• Rich Peripheral Set, Optimized for Audio
• Highly Optimized C/C++ Compiler
• Extended Temperature Devices Available
Advanced Very Long Instruction Word (VLIW) TMS320C67x DSP Core
• Eight Independent Functional Units:
- Two ALUs (Fixed-Point)
- Four ALUs (Floating- and Fixed-Point)
- Two Multipliers (Floating- and Fixed-Point)
• Load-Store Architecture with 64 32-Bit General-Purpose
Registers
• Instruction Packing Reduces Code Size
• All Instructions Conditional
 100

Instruction Set Features

• Native Instructions for IEEE 754

- Single- and Double-Precision
• Byte-Addressable (8-, 16-, 32-Bit Data)
• 8-Bit Overflow Protection
• Saturation; Bit-Field Extract, Set, Clear; Bit-Counting;
Normalization.

67x cache memory.

- 32K-Byte L1P Program Cache (Direct-Mapped)
- 32K-Byte L1D Data Cache (2-Way)
256K-Byte L2 unified Memory RAM\Cache.
Real-Time Clock With 32 KHz Oscillator and Separate Power Rail.
Three 64-Bit General-Purpose Timers
- Integrated Digital Audio Interface Transmitter (DIT)
Supports:
- S/PDIF, IEC60958-1, AES-3, CP-430 Formats
- Up to 16 transmit pins
- Enhanced Channel Status/User Data
- Extensive Error Checking and Recovery
Two Inter-Integrated Circuit Bus (I2C Bus™) .
3 64-Bit General-Purpose Timers (each configurable as 2 32-bit
timers)
Flexible Phase-Locked-Loop (PLL) Based Clock Generator Module
IEEE-1149.1 (JTAG) Boundary-Scan-Compatible
3.3-V I/Os, 1.2 -V Internal (GDP & PYP)
3.3-V I/Os, 1.4-V Internal (GDP)(300 MHz only)
Two Serial Peripheral Interfaces (SPI) Each With Multiple Chip-
Selects
Two Multimedia Card (MMC)/Secure Digital Card Interface with
Secure Data I/O (SDIO) Interfaces
One Multichannel Audio Serial Port.
Two Multichannel Buffered Serial Ports.

Code Composer Studio:

General Procedure to work on Code Composer Studio for non-real

time projects using target:
1. Launch CCS.
Launch the CCS v6 icon from the Desktop or goto All Programs
-> Texas Instruments -> CCSv7.
2. Choose the location for the workspace, where your project
will be saved.
 101

3. Creating a New Project:

Project → New CCS Project.
Specify the name of the project in the space provided e g.,
Project Name: test123

4. Specify the “Device” properties as shown in the figure below

choose the Linker command file: as “Linker_dsp.cmd” from

supporting folder. Click Finish.

Type your C Code and save.

 102

#include<stdio.h>
int main()
{
printf("Hello DSP LCDK");
return 0;
}

5. Build the program to check your code.

Go to
Project → Build project.
If your code doesn’t have any errors and warnings, then you
would see
“**** Build Finished ****”

6. DEBUG
After successful Build, connect the kit with the system using
the JTAG emulator and power the kit. Click the Debug as shown
in the below figure.

It will redirect to the Debug perspective automatically.

7. RUN
Wait until the program loaded to the hardware automatically.
Now you can run the code, by selecting Run-> Resume.
 103

Once you run the program the output will be printed in the
Console Window.

We can also double click on the Console Window to view it on

full screen.

RANDOM WAVE GENERATION:

#include<stdio.h>
#include<math.h>
#define PI 3.14
#define PTS 128
float x[PTS];
float y[PTS];
float z[PTS];
float n[PTS];
void main()
{
int i,j;
for (i = 0 ; i < PTS ; i++)
{
x[i] = sin(2*PI*i*20/128.0);
y[i]=0.0;
n[i]=x[i] + rand() * 10 ; //rand function to generate random
signal
}
}

RUN the program.

To view the values in graph, go to Tools → Graph → Single

Time
 104

Set the Graph Properties as

Buffer size: give some value (No. of samples 128) say.
DSP Data Type: 32-Bit floating point.
Start Address: n (variable used to collect random samples)
Display Data Size: 200 (say)
Click: Ok
 105

CIRCULAR CONVOLUTION:

/* prg to implement circular convolution */

#include<stdio.h>
int m,n,x[30],h[30],y[30],i,j,temp[30],k,x2[30],a[30];
void main()
{
printf(" enter the length of the first sequence\n");
scanf("%d",&m);
printf(" enter the length of the second sequence\n");
scanf("%d",&n);
printf(" enter the first sequence\n");
for(i=0; i<m; i++)
scanf("%d",&x[i]);
printf(" enter the second sequence\n");
for(j=0;j<n;j++)
scanf("%d",&h[j]);
if(m-n!=0) /*Iflenght of both sequences are not
equal*/
{
if(m>n) /* Pad the smaller sequence with zero*/
{
for(i=n;i<m;i++)
h[i]=0;
n=m;
}
for(i=m;i<n;i++)
x[i]=0;
m=n;
}
y[0]=0;
a[0]=h[0];
for(j=1;j<n;j++) /*folding h(n) to h(-n)*/
a[j]=h[n-j];

/*Circular convolution*/
for(i=0;i<n;i++)
y[0]+=x[i]*a[i];
for(k=1;k<n;k++)
{
y[k]=0;

/*circular shift*/
for(j=1;j<n;j++)
x2[j]=a[j-1];
x2[0]=a[n-1];
for(i=0;i<n;i++)
 106

{
a[i]=x2[i];
y[k]+=x[i]*x2[i];
}
}
/*displaying the result*/
printf(" the circular convolution is\n");
for(i=0;i<n;i++)
printf("%d \t",y[i]);
}

Conclusion: