DSP PROJECT

IMPLEMENTATION OF SOBEL EDGE DETECTION ON

TMS320C6748 AND RASPBERRY PI 3B+ WITH
CAMERA MODULE
SUBMITTED TO :

Professor Dr. Ravi Kumar Jatoth

Professor - Electronics & communication Engineering

SUBMITTED BY:

Rishendra Tiruveedhula – 21ECB0B48

Rudra Kalyan – 21ECB0B56

V Rahul – 21ECB0B65

ACKNOWLEDGEMENT
 We would like to express my utmost gratitude to our faculty in-charge
DR.J.RAVI KUMAR, Professor, Department of Electronics and
Communication Engineering and National Institute of Technology,
Warangal for their constant supervision, guidance, suggestion and
encouragement during this semester.

Table of contents
NO CONTENT
1. INTRODUCTION
2. COMPONENTS
3. Project Objectives
 3.1 Preprocessing an image using MATLAB

3.2 Implementing Sobel edge detection on the TMS320C6748 DSP

3.3 Verifying the output using the Image Analyzer tool in CCS
4.
5. WORKING
6. POWER SUPPLY
7. POWER SUPPLY CIRCUIT DIAGRAM
8. SIMULATION OUTPUT
9. HOW TO MAKE A .BRD FILE
9.1 What is EAGLE
9.2 HOW TO DRAW A SCHEMATIC DIAGRAM OF OUR CIRCUIT
10. Conclusion
11. References
Introduction:
In the realm of image processing and computer vision, edge detection plays a
pivotal role in identifying boundaries and significant features within an image. The
Sobel operator, a popular edge detection technique, is widely employed for its
simplicity and effectiveness in highlighting edges by emphasizing sudden intensity
changes.
This project aims to implement Sobel edge detection using two distinct platforms:

1. TMS320C6748 DSP (Digital Signal Processor)

The purpose of this project is the process of implementing Sobel edge detection on
the TMS320C6748 digital signal processor (DSP). The entire workflow involves
using MATLAB for preprocessing an image, converting it into grayscale, saving it
as a C header file, loading the header file into Code Composer Studio (CCS),
performing Sobel edge detection on the TMS320C6748, and finally verifying the
output image using the Image Analyzer tool in CCS.

2. Raspberry Pi with a camera module.

The Raspberry Pi setup involves capturing live video feed through the camera
module and processing it in real time using Python. The combination of the
Raspberry Pi's computational capabilities and the camera module's ability to
capture high-quality images allows for the seamless integration of edge detection
into various applications, such as surveillance, robotics, and automation.

Our project aims to demonstrate the versatility and performance of Sobel edge
detection in real-time scenarios, showcasing its potential impact across diverse
fields.
Components:
1.TMS 320C6748
Texas Instruments TMS320C6748 Fixed and Floating-Point DSP is a low-power
applications processor based on a C674x DSP core. This DSP provides
significantly lower power than other members of the TMS320C6000™ platform of
DSPs. The device enables original-equipment manufacturers (OEMs) and original
design manufacturers (ODMs) to bring to market devices quickly. These devices
come with robust operating systems, rich user interfaces, and high processor
performance through the maximum flexibility of a fully integrated, mixed-
processor solution.

2.Raspberry Pi 3B+
The Raspberry Pi 3 Model B+ is a single-board computer developed by the
Raspberry Pi Foundation. It is an enhanced version of its predecessor, the
Raspberry Pi 3 Model B, with improvements in processing power, connectivity,
and networking capabilities. Here are some key features and specifications of the
Raspberry Pi 3 Model B+:

Software used:
1. Matlab

2. Code Composer Studio(CCS)

Project Objectives:
The primary objectives include

1. Preprocessing an image using MATLAB

2. Implementing Sobel edge detection on the TMS320C6748 DSP

3. Verifying the output using the Image Analyzer tool in Code Composer Studio.
1. Preprocessing an image using MATLAB
Image Preprocessing with MATLAB:

The first step in the process is to preprocess the image using MATLAB. This
involves converting the image into grayscale, a common pre-processing step
for edge detection algorithms. The grayscale image is then saved as a C
header file, which contains the pixel values of the image.
1. Image Loading:
The first step is to load the original image into MATLAB. The image could
be obtained from various sources, such as a camera, database, or existing
dataset. Ensure that the image is in a format compatible with MATLAB, such
as JPEG or PNG.

Input image:

2. Grayscale Conversion:
Grayscale conversion simplifies the image to a single channel, representing
intensity or luminance. This step is crucial for edge detection algorithms like
Sobel, which primarily rely on changes in intensity. The rgb2gray function in
MATLAB is commonly used for this purpose

Output image:

3. Image Enhancement :

Depending on the quality of the original image or specific requirements, optional

enhancement techniques may be applied. Techniques such as contrast adjustment,
histogram equalization, or noise reduction can be employed to improve the overall
quality of the image.

4. Saving as C Header File:

Once the preprocessing steps are complete, the grayscale image needs to be saved
as a C header file. This file will contain the pixel values of the image, organized in
a way that is suitable for direct inclusion in the code

This code snippet opens a file named 'image_data.h' in write mode, writes the pixel
values as an array, and saves the file. The resulting 'image_data.h' file can be
included in the Code Composer Studio project for use on the TMS320C6748.
2. Implementing Sobel edge detection on the
TMS320C6748 DSP
Code Composer Studio Setup:

Setting up Code Composer Studio (CCS) is a crucial step in the Sobel edge
detection project on the TMS320C6748. CCS is an integrated development
environment (IDE) designed for Texas Instruments' DSPs, providing tools for code
development, debugging, and performance analysis. The following steps outline
the process of setting up CCS for this project:

1. Installation:

Ensure that Code Composer Studio is installed on the development machine.

Download the latest version from the Texas Instruments website and follow the
installation instructions provided. This step includes installing necessary drivers,
libraries, and toolchains for the TMS320C6748 DSP.

2. Project Creation:

Create a new CCS project to encapsulate all the code, settings, and configurations
for the Sobel edge detection implementation. Use the appropriate project template
for TMS320C6748 DSP.

● Open Code Composer Studio.

● Select "File" -> "New" -> "CCS Project."
● Choose the appropriate project type for TMS320C6748 DSP.
● Specify the project name, location, and other relevant details.

3. Project Configuration:

Configure the project settings to match the requirements of the TMS320C6748

DSP.

● Set the target processor to TMS320C6748.

● Configure compiler settings, including optimization levels, include paths,
and preprocessor directives.
● Specify linker settings to link relevant libraries and object files.
● Configure build settings for generating the appropriate output format (e.g.,
ELF or TI COFF).
4. Header File Inclusion:

Include the header file generated during the MATLAB image preprocessing stage
into the CCS project. This file contains the pixel values of the preprocessed image
in a format suitable for direct inclusion in the code.

5.Code Development:

Write or import the C code for the Sobel edge detection algorithm into the CCS
project. Utilize the DSP-specific features and libraries available for efficient image
processing.

6. Build and Compilation:

Build the project to compile the code and generate the executable file for the
TMS320C6748 DSP.

● Click on the "Build" or "Compile" button in the CCS toolbar.

● Check the console for any build errors and address them accordingly.

7. Code Loading:

Load the compiled code onto the TMS320C6748 DSP for execution.

● Connect the DSP target to the development machine.

● Use the appropriate debugging and programming tools within CCS to load
the code onto the DSP.

8. Debugging:

Debug the code using the CCS debugger to identify and fix any issues. Utilize
breakpoints, variable inspection, and other debugging features to ensure the correct
execution of the Sobel edge detection algorithm.
9. Output Verification:

We used the Image Analyzer tool within Code Composer Studio to visually inspect
and verify the output of the Sobel edge detection algorithm applied to the image
loaded on the TMS320C6748.
Sobel Edge Detection Implementation:
Sobel edge detection is a gradient-based method commonly used for edge detection
in image processing. The algorithm uses convolution masks to compute the
gradient of the image intensity, highlighting areas with rapid changes in intensity,
which typically correspond to edges. Here is a more detailed explanation of the
Sobel edge detection implementation:

1. Sobel Operator:

The Sobel operator consists of two 3x3 convolution masks, one for detecting
changes in the horizontal direction (Sobel-X) and the other for changes in the
vertical direction (Sobel-Y). These masks are designed to approximate the
derivative of the image intensity.

Sobel-X Mask:

Sobel-Y Mask:

2. Image Convolution:

The Sobel masks are convolved with the grayscale image to calculate the gradient
in both the horizontal and vertical directions. The convolution operation involves
sliding the masks over the image and computing the weighted sum of the pixel
values in each neighborhood. The resulting gradients, one for Sobel-X and one for
Sobel-Y, are combined to obtain the magnitude of the gradient.

3. Gradient Magnitude:

The gradient magnitude GG is calculated as:

G=Gx2+Gy2G=Gx2+Gy2

where GxGx and GyGy are the gradients obtained from the Sobel-X and Sobel-Y
masks, respectively. The magnitude represents the strength of the edge at each
pixel.

4. Edge Direction:

The edge direction θθ can be calculated as:

θ=arctan⁡(GyGx)θ=arctan(GxGy)

This direction information is not always necessary for basic edge detection but can
be useful in more advanced applications.

5. Thresholding:

To obtain a binary image highlighting edges, a thresholding step is applied to the

gradient magnitude. Pixels with gradient magnitudes above a certain threshold are
considered part of an edge, while those below are suppressed.
6. Implementation in C:

The Sobel edge detection algorithm is implemented in C using nested loops to

perform the convolution operation on each pixel of the image. The resulting edge-
detected image is then saved or displayed.
7. Optimization:

For real-time applications on embedded systems like the TMS320C6748,

optimizations may be applied to enhance the efficiency of the algorithm.
Techniques such as loop unrolling, parallelization, and hardware acceleration can
be explored to make the Sobel edge detection process more computationally
efficient.

8. Debugging:

Debug the code using the CCS debugger to identify and fix any issues. Utilize
breakpoints, variable inspection, and other debugging features to ensure the correct
execution of the Sobel edge detection algorithm.
3. Verifying the output using the Image
Analyzer tool in Code Composer Studio.
After implementing the Sobel edge detection algorithm on the TMS320C6748, it is
essential to verify the output to ensure the algorithm functions correctly and
accurately highlights edges in the image. The verification process involves using
tools such as the Image Analyzer within Code Composer Studio (CCS) to visually
inspect and analyze the output. Here's a detailed explanation of the output
verification process:

1. Image Analyzer Tool:

Code Composer Studio provides a powerful tool called the Image Analyzer for
visualizing and analyzing image data. This tool allows developers to view images
pixel by pixel, making it suitable for inspecting the results of image processing
algorithms like Sobel edge detection.

2. Loading the Output Image:

The first step in output verification is loading the output image generated by the
Sobel edge detection algorithm into the Image Analyzer tool. This image should be
the result of applying the Sobel operator to the preprocessed input image.

3. Visual Inspection:

The Image Analyzer tool provides a visual representation of the output image,
allowing for pixel-level inspection. Developers can visually inspect the image to
ensure that edges are appropriately highlighted, and non-edge areas remain
relatively dark. Verify that the algorithm has detected the edges in accordance with
the expected behavior.

Introduction:
The purpose of this project is the process of implementing Sobel edge detection on
the TMS320C6748 digital signal processor (DSP). The entire workflow involves
using MATLAB for preprocessing an image, converting it into grayscale, saving it
as a C header file, loading the header file into Code Composer Studio (CCS),
performing Sobel edge detection on the TMS320C6748, and finally verifying the
output image using the Image Analyzer tool in CCS.