VISVESVARAYA TECHNOLOGICAL UNIVERSITY

BELAGAVI – 590018

A
Seminar report
on
“ AI POWERED DRONE ”

Submitted in partial fulfillment for the award of the degree of

Bachelor of Engineering
in
Computer Science and Engineering

Submitted by:
Vidyasagar Jamadar
(3LA21CS055)

Under the Guidance of:

Prof. Aruna Kawdi
Asst. Professor

Department of Computer Science and Engineering

Lingaraj Appa Engineering College, Gornalli,

Bidar – 585403
2024-2025
 Lingaraj Appa Engineering College
Gornalli, Bidar – 585403
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

CERTIFICATE

This is to certify that the Seminar work entitled “ AI POWERED DRONE ” has been successfully carried
out by Vidyasagar Jamadar bearing USN 3LA21CS055 Lingaraj Appa Engineering College in partial
fulfillment of the requirements for the award of degree in Bachelor of Engineering in Computer Science
and Engineering of Visvesvaraya Technological University, Belagavi during academic year 2024-
2025. It is certified that all theory/practical/corrections/suggestions indicated have been executed under
the directions of Prof. Aruna Kawdi. The Seminar report has been approved as it satisfies the academic
requirements in respect of Seminar work for the said degree.

__________________ ____________________ _________________

Prof. Aruna Kawadi Dr. Vivek Jaladi Dr. Vinita Patil

Guide H.O.D Principal

Name of the Examiners Signature with Date

1.
2.
 DECLARATION
I, Vidyasagar Jamadar bearing USN 3LA21CS055, student of 8th semester B.E. Department of
Computer Science and Engineering, Lingaraj Appa Engineering College, Bidar, declare that the
Seminar work entitled “ AI POWERED DRONE ”, has been duly executed by me under the guidance
of Prof. Aruna Kawdi, Asst. Professor, Department of Computer Science and Engineering. The Seminar
report of the same is submitted in partial fulfillment of the requirement for the award of Bachelor of
Engineering degree in Department of Computer Science and Engineering by Visvesvaraya Technological
University, Belgaum during the year 2024-2025.

Date:
Place: Bidar

Vidyasagar Jamadar
3LA21CS055
 ACKNOWLEDGEMENT
The satisfaction that accompanies the successful completion of the seminar report which would be complete only
with the mention of the almighty God and the people who made it possible, whose report rewarded the effort with
success of seminar presentation.

I express our sincere thanks to our President Poojya Dr. Sharanbasawappa Appaji and Secretary Shri.
Basavaraj Deshmukh for providing all the required Facilities for the completion of the seminar work.

I am grateful to Lingaraj Appa Engineering College for providing us an opportunity to enhance our knowledge
through the seminar. I express our sincere thanks to Dr. Vinita Patil, Principal, LAEC for providing us an
opportunity and means to present the seminar.

I express my heart full thanks to Dr. Vivek Jaladi, Professor and Head, Department of Computer Science and
Engineering, for encouragement in our seminar work, whose cooperation and guidance helped in nurturing this
seminar report.

I would like to express profound thanks to the guide Prof. Aruna Kawdi, Asst. Professor, Project head and
Internal Guide, Department of Computer science and Engineering for the keen interest and encouragement in our
seminar presentation.

I extend our thanks to all the helping staff for their effort and endurance to bring out the best in us. Finally, we
would like to thank my family members and friends for stand and support.

Date :

Place : Bidar

Vidyasagar Jamadar
3LA21CS055
 ABSTRACT

In recent years, Unmanned Aerial Vehicles (UAVs), commonly known as drones, have undergone a revolutionary
transformation with the integration of Artificial Intelligence (AI). AI-powered drones are no longer limited to
basic remote-controlled devices; they now possess autonomous capabilities such as obstacle detection, real-time
decision-making, and adaptive navigation. This seminar report explores the rapid advancement of drone
technology through the lens of AI, focusing on key aspects such as drone-based learning, RF-based drone
detection, GPS and GIS integration, and innovative navigation systems using MEMS inertial sensors.

One major highlight is the fusion of Global Positioning System (GPS) and Geographic Information Systems (GIS)
to enhance operational precision in sectors like agriculture, logistics, and disaster management. Furthermore, the
report discusses how GPS/INS integrated navigation systems, powered by MEMS sensors, provide highly
accurate positioning even in GPS-denied environments. The use of RF-based detection methods also presents
critical security solutions against unauthorized or hostile drones.

From educational tools to advanced surveillance, delivery systems, and environmental monitoring, AI drones are
transforming traditional workflows across industries. This report also addresses the challenges such as privacy,
regulatory frameworks, and technical limitations, while outlining future trends like swarm intelligence, solar-
powered UAVs, and 5G-enabled drone networks. AI-powered drones stand at the forefront of the next
technological frontier, promising a smarter, safer, and more connected future.
 TABLE OF CONTENTS

CHAPTER CHAPTER NAME PAGE

NO. NO.

1 Introduction to AI Powered Drones 1–2

1.1 Definition of Drone

1.2 Evolution from manually operated UAVs to AI-enabled
drones

2 Importance of AI in Drones 3–4

2.1 Real-Time Object Detection

2.2 Autonomous Navigation and Decision Making
2.3 Machine Learning for Target Tracking

3 Drone Technologies and Applications 5–8

3.1 Surveillance and Defense

3.2 Agriculture
3.3 Industrial Inspection
3.4 Entertainment
3.5 Healthcare

4 RF-Based Drone Detection 9 – 11

4.1 RF Signature Analysis

4.2 Detecting Drones Through Frequency Spectrum
Monitoring
4.3 Counter-Drone Technology

5 Design and Implementation of GPS and GIS 12 – 13

5.1 GPS: Satellite-Based Navigation

5.2 GIS: Geospatial Information Systems
5.3 Integration of GPS and GIS for Drone Path Planning

6 Global Positioning System Applications 17 – 18

6.1 Accurate Positioning and Route Mapping

6.2 Delivery and Logistic Services
6.3 Rescue Missions and Disaster Management
6.4 Agricultural Field Mapping

7 Implementation and Performance of GPS/INS 22 – 23

7.1 MEMS-Based Sensors

7.2 Benefits of GPS-INS Integration
8 Challenges and Future Scope 24 – 25

8.1 Challenges in AI-Powered Drone Deployment

8.2 Emerging Research Areas
8.3 The Future of AI-Powered Drone Systems

9 Conclusion 26

References 27
 LIST OF FIGURES

FIG NO. FIGURE NAME PAGE

NO.
1.1 Evolution of Drone Technology timeline………………………... 1

2.1 AI Workflow in Drone Operations………………………………. 4

3.1 Various Applications of Drones in Different Industries…………. 5

4.1 RF Signal Detection Diagram…………………………………… 10

6.1 GPS-enabled Drone Path Map…………………………………... 14

8.1 Challenges and Future Possibilities……………………………… 20

 LIST OF TABLES

TABLE TABLE NAME PAGE

NO. NO.
7.1 Key benefits of GPS/INS integrated system…………………….. 17 - 18
 INTERNSHIP REPORT – URSC, ISRO

CHAPTER - 1
INTRODUCTION
This internship was conducted at the Indian Space Research Organisation (ISRO),
specifically under the UR Rao Satellite Centre (URSC), located in Bengaluru. ISRO is
India’s premier space research organization, responsible for developing and managing the
nation’s space-based capabilities, including satellite launches, remote sensing, navigation, and
scientific exploration.

The URSC plays a crucial role in the design, development, and integration of satellite payloads
and control systems that are deployed in space missions. Being a part of such a prestigious
institution provided a unique opportunity to work on real-world challenges in aerospace
software engineering.

The primary objective of this internship project was to support the validation and testing of
legacy satellite software developed in the ADA programming language. Many of ISRO’s
older satellite systems have been built using ADA, a language known for its strong typing,
modularity, and reliability—key features required for mission-critical applications like satellite
control systems.

Over time, maintaining and updating these large, complex codebases has become increasingly
challenging, especially in the absence of automated tools to aid in the software analysis process.
The project aimed to address this gap by creating utilities that simplify the understanding and
inspection of decision-making logic within ADA code.

To achieve this, the project was divided into two major components:

a. Python-based ADA Code Analysis Tool:

The first component involved developing a Python utility to extract if-else conditions and
other decision-making constructs from ADA source files. These conditions often represent
critical branching logic in control systems, and being able to isolate and analyze them is
essential for understanding how the software reacts to various input scenarios.

This tool uses static code analysis and integrates the Understand API—a commercial tool
used for parsing and analyzing large codebases. The automated extraction of control logic
significantly reduces manual effort and allows engineers to focus on interpretation and
validation rather than basic inspection.

b. Web-Based Visualization Interface

The second component focused on building a lightweight, PHP-based web interface to

visually inspect the extracted logic. This interface presents the data in a clear, structured
format using a combination of PHP, JavaScript, and HTML/CSS. It enables users to:

1
 INTERNSHIP REPORT – URSC, ISRO

o Navigate through ADA files

o View extracted conditional logic

o Understand the software flow graphically

This layer of visualization helps testers and engineers quickly interpret the behavior of complex
systems, facilitating better collaboration and faster validation cycles.

Throughout the internship, regular reviews and feedback sessions were conducted under the
guidance of Prasanna Kumar Sir, Division Head, Reliability and Quality Assurance
Software Group, URSC whose expertise in satellite control software was instrumental in
shaping the design and scope of the tools. His mentorship ensured that the work aligned with
real-world engineering needs and adhered to ISRO’s software development standards.

In conclusion, this internship provided valuable hands-on experience at the intersection of

software engineering and aerospace systems. It emphasized the critical role of automation and
tool development in managing legacy codebases and demonstrated how backend logic analysis
and frontend usability can be combined to enhance software validation efforts. The tools
developed have the potential for further enhancement and could be integrated into ISRO’s
broader software verification and maintenance workflows, contributing to the efficiency and
reliability of future satellite missions.

2
 INTERNSHIP REPORT – URSC, ISRO

CHAPTER - 2
PROBLEM STATEMENT
“ Build a Python-based test case generation utility and a PHP-based web interface to extract
and display all decision-making (IF statements) conditions present in ADA code analyzed
through the Understand tool, specifically from heritage satellite projects. ”

In the context of heritage satellite projects at the Indian Space Research Organisation
(ISRO), the analysis and validation of legacy software—especially those written in the ADA
programming language—are crucial for ensuring reliability, safety, and correctness. These
legacy systems, developed over several decades, form the backbone of mission-critical satellite
control functionalities. However, their age and complexity pose significant challenges for
current validation and quality assurance teams. Manual inspection of such software is time-
consuming, error-prone, and inefficient, particularly when trying to trace decision-making
logic embedded in large codebases.

One of the key requirements in understanding and testing such legacy code is the ability to
identify and analyze decision-making constructs, particularly IF statements, which dictate
conditional behavior and branching logic. These statements play a central role in defining the
system’s response to various operational conditions. Without dedicated tools to isolate and
inspect these decision points, engineers must resort to manual code review—a process that
lacks scalability and repeatability.

To address this challenge, the proposed solution is to develop an automated toolchain

consisting of the following components:

a. A Python-based utility that integrates with the Understand tool to parse ADA source
code and extract all IF statement conditions. The tool will leverage the Understand API
to navigate the code’s abstract syntax structure and extract relevant conditional
expressions systematically and accurately.

b. A PHP-based web interface designed for user-friendly visualization of the extracted

data. This interface will allow engineers to browse through ADA source files, view the
conditions in a readable format, and interact with the decision logic for further analysis
and validation. The interface aims to make the extracted data accessible to both
developers and testing teams, enhancing the efficiency of the software validation
process.

This project directly supports ISRO’s ongoing efforts to modernize its software analysis
workflows and improve the reliability and maintainability of satellite control software. By
automating the extraction and inspection of decision logic, the tools developed will contribute
significantly to reducing manual effort, improving accuracy, and accelerating the testing cycles
of heritage systems.

3
 INTERNSHIP REPORT – URSC, ISRO

CHAPTER - 3
SCOPE
The scope of this project is carefully defined to target a specific yet critical area within the
domain of software analysis for legacy satellite systems. Given the complexity of embedded
systems and the critical role of decision logic in real-time operations, the project is focused on
extracting, analyzing, and presenting decision-making conditions—specifically IF
statements—from ADA codebases used in ISRO’s heritage satellite projects.

3.1. Language and Tool Constraints

The implementation of this project is intentionally limited to two core technologies to ensure
a focused and maintainable development cycle:

 Python is used for backend code analysis. It is selected for its simplicity, readability,
and extensive support for integration with APIs such as the Understand API. Python’s
data handling capabilities, combined with scripting efficiency, make it ideal for
automating code analysis tasks.

 PHP, along with HTML, CSS, and JavaScript, is used to develop the web interface.
PHP was chosen due to its ease of deployment in web environments and its
compatibility with server-side data handling. The web interface provides a lightweight
and accessible platform for engineers to interact with the extracted decision logic.

These technology constraints align with the requirements of the hosting environment at ISRO
and ensure that the resulting tools can be easily deployed within internal systems without the
need for complex dependencies or additional infrastructure.

3.2. Focus on IF Statements

The analysis is narrowly scoped to focus on IF conditions, which are among the most
fundamental constructs in any control-based software system. In embedded systems—such as
satellite on-board software—IF statements are often used to handle sensor data, execute safety
checks, trigger control signals, and manage fault-tolerant behavior.

The rationale behind limiting the scope to IF conditions includes:

 Critical Decision Points: IF statements govern essential branches in execution, and

understanding them provides deep insight into the software's functional and safety
behavior.

 Targeted Output: Extracting these statements serves as a stepping stone for generating
test cases, performing condition coverage analysis, and verifying logic consistency.

4
 INTERNSHIP REPORT – URSC, ISRO

 Feasibility within Internship Timeline: A narrow focus allows for meaningful

progress, testing, and refinement within the limited time and resources available for the
internship.

Future work may extend this functionality to include other control structures such as CASE,
LOOP, and exception handling constructs, but those are outside the current project’s scope.

3.3. Integration with Understand Tool

The project depends on the Understand static analysis tool, which provides a detailed
syntactic and semantic breakdown of the source code. The Python utility utilizes the
Understand API to:

 Traverse the abstract syntax tree (AST) of ADA programs

 Locate and extract all IF conditions, along with their contextual information (such as
function names and line numbers)

 Organize the extracted data for downstream processing and display

This dependency ensures that the analysis is accurate, scalable, and robust, even for large and
deeply nested legacy codebases.

3.4. Output for Testing and Validation

The primary output of the project—the extracted conditional logic—is not an end in itself
but is intended for use in testing and validation workflows. The generated data can be used
by testing teams to:

 Understand the software's decision pathways

 Derive meaningful test cases

 Perform condition and branch coverage analysis

 Identify unreachable or dead code segments

 Support reverse engineering and documentation efforts

By providing an accessible interface and structured output, the tools developed in this project
serve as enablers for higher-level software quality assurance processes.

5
 INTERNSHIP REPORT – URSC, ISRO

CHAPTER - 4
TOOLS USED
The development of the test case generation utility and web interface for extracting and
displaying IF conditions in legacy ADA code relied on a variety of powerful and specialized
tools. These tools enabled efficient, scalable, and accurate analysis, extraction, and presentation
of decision-making logic. Below is an overview of each tool used in the project:

4.1. Understand by SciTools

Understand is a static analysis tool that provides comprehensive insights into the structure,
logic, and relationships within source code. It supports a wide range of programming
languages, including ADA, and offers a robust API for automating code analysis tasks.

 Functionality: Understand was integral to parsing and analyzing the ADA codebases.
It allows for detailed exploration of the code, generating an abstract syntax tree (AST)
of the entire program. This structure helps identify all decision-making constructs,
such as IF statements, by mapping them to specific code locations and contextual
information (e.g., functions, loops, and variable names).

 Usage: The Python utility developed in this project integrates with the Understand API
to extract IF conditions and their associated data. By leveraging the API’s ability to
traverse and understand complex code structures, we can efficiently target and isolate
conditional logic, even in large and legacy systems. Understand’s static analysis
capabilities ensure high accuracy and scalability in processing extensive codebases that
are typical in satellite software systems.

4.2. Python

Python was chosen as the core language for backend development due to its readability,
flexibility, and rich ecosystem of libraries, making it ideal for rapid prototyping and automation
tasks.

 Functionality: The Python-based utility interacts with the Understand API to

automate the extraction of IF conditions from ADA code. Python’s strong text-
processing capabilities and ease of integration with other tools enabled efficient
parsing, extraction, and formatting of the decision logic.

 Features:

o Automation of extraction process: Python scripts automate the parsing and

filtering of ADA code to extract IF statements and other conditional constructs.

o Data organization: Extracted data is organized in a structured format (e.g.,

JSON or CSV), which can be later rendered in the web interface for inspection.

6
 INTERNSHIP REPORT – URSC, ISRO

o Ease of testing: Python’s simplicity allowed for quick testing and iterative
development, ensuring that the utility worked efficiently with various ADA
codebases and could scale for large projects.

 Libraries Used: Python libraries like os for file handling, json for data structuring, and
requests for API communication were essential in developing the backend
functionality of the utility.

4.3. PHP + JavaScript + HTML/CSS

To present the extracted conditional logic in a user-friendly format, a web interface was
developed using a combination of PHP, JavaScript, HTML, and CSS. This front-end solution
ensures that the engineers and testers can interact with the extracted data intuitively and
efficiently.

 PHP: The server-side scripting was handled by PHP, which was responsible for
fetching the extracted data from the backend, formatting it, and passing it to the front
end. PHP's ability to interact seamlessly with databases and dynamically generate
HTML content makes it an excellent choice for server-side operations in web
applications.

 JavaScript: JavaScript enhanced the interactivity of the web interface. It was used to
create interactive elements like collapsible tables, data filtering, and pagination,
ensuring that users could easily navigate and view large datasets extracted from the
ADA code. JavaScript also allows for asynchronous data loading (AJAX), improving
the responsiveness and user experience.

 HTML/CSS: HTML was used for structuring the web interface, while CSS ensured
that the interface was aesthetically appealing and easy to navigate. The design focused
on simplicity and clarity, presenting the extracted decision logic in a clean, readable
format. With minimal clutter, the layout emphasized ease of use and quick access to
relevant information.

The combination of PHP for server-side processing and JavaScript/HTML/CSS for client-side
interaction allowed the web interface to deliver real-time data updates, ensuring an efficient
workflow for users.

4.4. Jupyter Notebook

Jupyter Notebook is an open-source tool that facilitates interactive development, data

analysis, and testing of Python code in a web-based environment. It was extensively used
during the development and testing phases of the backend Python utility.

 Functionality: Jupyter Notebook provided an interactive environment for quickly

testing individual Python scripts, analyzing outputs, and debugging issues related to the
extraction process. It enabled the development of small, manageable chunks of code

7
 INTERNSHIP REPORT – URSC, ISRO

that could be tested and iterated upon without the need for setting up a complex IDE or
running a full application.

 Features:

o Rapid prototyping

o Visualization

 Testing & Debugging: With Jupyter Notebook, individual components of the utility
could be tested in isolation, ensuring the functionality worked as expected before
integrating them into a full-fledged system.

8
 INTERNSHIP REPORT – URSC, ISRO

CHAPTER - 5
PROJECT REFERRED
The project focused on analyzing and extracting decision-making conditions from the legacy
ADA code used in the GSAT-7R satellite mission, specifically within the Attitude and Orbit
Control Electronics (AOCE) system. The GSAT-7R is one of ISRO’s important
communication satellites, designed to provide mobile communication services to users across
India. Its success is largely dependent on the effectiveness and reliability of the embedded
systems responsible for its orientation and orbital control.

The Attitude and Orbit Control Electronics (AOCE) system is vital for determining the
satellite's orientation in space and managing its orbital trajectory. This system is responsible
for controlling the satellite’s position, velocity, and orientation relative to Earth and other
celestial bodies. The accuracy of these functions directly impacts the satellite’s ability to
maintain a stable orbit and ensure the performance of its communication payloads.

Given the complexity and mission-critical nature of this system, the software embedded in the
AOCE is developed in the ADA programming language. ADA was chosen for its strong
typing, modularity, and high reliability—features essential for safety-critical systems like
satellite control software. Over the years, the software for the AOCE system has evolved into
a complex codebase that is difficult to manage and maintain. As such, understanding and
validating the decision-making logic embedded in this code is a significant challenge.

The analysis of this ADA code, as part of this internship project, focused on extracting IF
statements, which represent key decision points in the AOCE system’s control algorithms.
These conditions are essential for understanding how the system responds to sensor data,
executes fault detection routines, and triggers corrective actions in response to operational
anomalies. Ensuring the accuracy of these decision-making constructs is crucial to maintaining
the integrity and reliability of the satellite’s orbital control functions.

By focusing on extracting and visualizing these critical logic points, the project aims to improve
the validation and testing of the AOCE system, ensuring that the software behaves as expected
and is free from errors that could jeopardize the satellite’s mission. The tools developed in this
project serve as an important step in the ongoing effort to modernize ISRO’s satellite software
validation workflows and enhance the reliability of its space-based systems.

9
 INTERNSHIP REPORT – URSC, ISRO

CHAPTER - 6
CHALLENGES AND SOLUTIONS
During the initial phase of the internship, the integration of Python with the Understand tool
posed significant challenges. Although Understand provides an API to interact with
codebases, the documentation and examples for integrating it with Python were scarce and
often fragmented. As a result, much of the initial work involved extensive trial and error, which
spanned 10–12 days of configuring the environment, resolving dependencies, and
comprehending the object structure of the Understand database.

Once the integration with Understand was successful, the next major hurdle was navigating
the complex ADA codebase. ADA, known for its verbosity and structured syntax, presented
difficulties in parsing the decision-making logic. Specifically, the IF statements in ADA code
were often nested to several levels, and the code was divided into different procedural scopes.

To overcome these hurdles, a systematic and iterative approach was adopted:

 Incremental Development: Over 30+ Python scripts were developed, each

addressing a specific aspect of the extraction logic. Each script focused on refining one
element of the process, such as:

o Handling nested IF statements

o Skipping irrelevant or redundant conditions

o Formatting the output in a readable and structured format

 Debugging and Validation: Debugging was a critical part of the process, as the ADA
codebase was large and complex. Two primary methods were used for validation:

a. Print-based inspection: Logs and debug messages were inserted throughout the
scripts to trace the flow of the code and identify where errors might have occurred.

b. Jupyter Notebook: This interactive environment provided an efficient way to test

smaller code blocks, validate the correctness of individual steps, and experiment
with different configurations before integrating them into the full solution. The
ability to run Python code in a step-by-step manner was invaluable for
troubleshooting and refining the logic.

Despite the initial setbacks, the persistence and iterative nature of development led to a robust
solution. The final utility successfully extracted and structured the decision-making
conditions (i.e., IF statements) from the ADA codebase, providing a reliable foundation for
further testing and validation. This experience taught valuable lessons in problem-solving,
debugging, and the importance of a structured approach to software development.

10
 INTERNSHIP REPORT – URSC, ISRO

CHAPTER - 7
APPROACH AND ALTERNATIVES
During the development of the Python utility, two distinct approaches were considered for
extracting decision-making parameters from the ADA code:

a. Direct API Extraction (Decision-Based Parsing): This method involves directly

identifying decision-making constructs by querying the Understand API for specific
statement types such as:

o if

o elseif

o when

o while

o for

o case/switch
This approach provides a comprehensive overview of all conditional and
control-flow logic within the code. It has the advantage of being extensible and
offering complete coverage of decision-making constructs.

b. Range-Based Text Extraction (IF to THEN Parsing): In this approach, the script
identifies the range from the IF keyword to the corresponding THEN keyword,
capturing the condition in between. All subsequent keywords like END IF are
excluded. While this method limits extraction strictly to IF statements, it was selected
during the initial phase of the internship due to its relative simplicity and the ease of
implementation with limited time and resources.

Trade-Off Analysis:

 Chosen Method: Range-Based (IF to THEN)

o Simpler to implement initially

o Effective for focused validation on IF conditions

o Misses other control structures like WHILE, FOR, CASE

 Alternative Method: Direct API-Based

o More robust and versatile

o Requires deeper understanding of the code model and more complex script
logic.

11
 INTERNSHIP REPORT – URSC, ISRO

CHAPTER - 8
DESIGN

8.1. Python Utility(PsuedoCode):

12
 INTERNSHIP REPORT – URSC, ISRO

8.2. Web Interface (PHP Design Outline)

The Web Interface is responsible for presenting the extracted IF conditions to engineers and
testers in an intuitive, searchable, and filterable format. It is built using PHP, JavaScript,
HTML, and CSS, ensuring a dynamic, interactive, and responsive user experience.

General Design:

a. Data Input:

o The web interface first loads the extracted conditions in JSON or CSV format,
depending on the output of the Python utility. This is done via PHP file handling
mechanisms.

b. Searchable and Filterable List:

o The extracted IF conditions are displayed in a list format with the following
columns:

 File Name

 Line Number

 Enclosing Procedure

 Condition

o The list is searchable by all fields, allowing users to quickly find specific
conditions or procedures. Additionally, filtering options are provided to display
only conditions from specific files or procedures.

c. Highlight Source File and Location:

o When users click on a specific condition, the source code is displayed with the
corresponding IF statement highlighted in the context of the surrounding code.
This allows engineers to quickly review the exact location and structure of each
decision-making condition.

d. Exporting Conditions:

o The web interface allows engineers to export the filtered and searched list of IF
conditions into various formats (e.g., CSV or PDF). This export functionality
supports test planning and documentation efforts.

e. Interactive Features:

o Sorting and Pagination: The list of IF conditions can be sorted by file name,
line number, or procedure name. Pagination ensures that large datasets are
manageable, displaying a limited number of entries per page.

13
 INTERNSHIP REPORT – URSC, ISRO

CHAPTER - 9
CODE
This section breaks down the various components of the project, including Python, PHP,
JavaScript, and Bootstrap, each contributing to the overall functionality of the test case
generation utility and the web interface. These technologies were chosen for their robustness,
ease of integration, and ability to handle the project’s requirements.

9.1. Python: Using Understand API to Gather IF Statement Metadata

The Python utility served as the backend for extracting the metadata of IF statements from
ADA code. The Understand API was leveraged to analyze the ADA code, traverse the
codebase, and extract relevant information about decision-making conditions. This information
included the file name, line number, enclosing procedure, and the condition itself.

Key Python Components:

a. Integration with Understand API:

o The Python script interfaces with the Understand tool to parse and extract
metadata from the .udb database.

o Python makes use of the Understand API to traverse the code structure,
searching specifically for lines containing IF statements.

b. Condition Extraction:

o The core functionality involves iterating over all the procedures and functions
in the ADA code, checking each line for IF conditions, and storing relevant
metadata.

o Each IF condition is captured with essential details such as:

 File Name: Identifies the source file containing the condition.

 Line Number: Pinpoints the exact line in the code.

 Enclosing Procedure: Associates the condition with the procedure in

which it resides.

 Condition: The actual decision-making expression evaluated by the IF

statement.

c. Output (JSON/CSV):

14
 INTERNSHIP REPORT – URSC, ISRO

o Once the metadata is extracted, the Python script outputs the data in JSON or
CSV format, which can be easily consumed by the web interface for further
display and interaction.

Example Python Code (Extracting IF Conditions):

This Python script ensures that the data extraction process is automated, scalable, and can
handle large legacy codebases efficiently.

9.2. PHP: Displaying IF Statement Records with Dynamic Filters

The PHP component handles the server-side logic for rendering and displaying the extracted
IF conditions in a web interface. PHP is responsible for reading the JSON/CSV files exported
by the Python utility and presenting the data dynamically.

Key PHP Components:

a. Loading Data:

o The PHP script loads the JSON/CSV file containing the extracted IF conditions
and stores it for use in the frontend display.

b. Displaying Data in a Table:

o The conditions are displayed in a table format, with columns for file name, line
number, enclosing procedure, and condition.

15
 INTERNSHIP REPORT – URSC, ISRO

o PHP iterates over the records and outputs each condition in a row, allowing
users to inspect the extracted data.

c. Search and Filter Functionality:

o PHP provides the logic to support dynamic filtering and searching of IF

conditions, allowing engineers to filter by file name, line number, or
procedure name.

PHP Code (Loading and Displaying Conditions):

The PHP code allows the user to view the extracted conditions in an easy-to-read format, which
can be dynamically filtered or searched through using JavaScript.

9.3. JavaScript: Adding Interactivity (Search, Sort, and Navigation)

JavaScript plays a crucial role in enhancing the interactivity of the web interface. It enables
dynamic filtering, searching, and sorting of the displayed IF conditions, improving the user
experience.

16
 INTERNSHIP REPORT – URSC, ISRO

Key JavaScript Features:

a. Search Functionality:

o Users can search for specific IF conditions based on keywords or any of the
displayed fields (e.g., file name, line number, condition).

o The search results are updated in real-time as the user types, allowing for
efficient exploration of large datasets.

b. Sorting:

o JavaScript allows sorting the IF conditions by file name, line number, or

enclosing procedure.

o This feature helps users quickly find and focus on relevant conditions.

c. Dynamic Table Updates:

o The table content is updated dynamically without needing to refresh the page,
ensuring a smooth and responsive user interface.

JavaScript Code (Search Functionality):

This JavaScript function listens for input in the search box and filters the displayed rows
accordingly.

17
 INTERNSHIP REPORT – URSC, ISRO

CHAPTER - 10
RESULT
The project achieved its primary objective of extracting decision-making conditions (IF
statements) from the legacy AOCE ADA code used in the GSAT-7R satellite mission. Below
are the key results and outcomes of the project:

10.1. Extraction of IF Conditions

 The Python-based utility successfully extracted over 300 IF conditions from the
AOCE ADA codebase. These conditions represented key decision points in the satellite
control software, which is essential for the spacecraft's attitude and orbit control.

 The extraction process involved parsing a large and complex codebase, which was a
significant challenge due to the verbosity and nested structure of ADA code. However,
the final Python script was able to reliably identify, capture, and record each IF
condition along with its corresponding metadata (e.g., file name, line number, enclosing
procedure).

10.2. Web Interface for Visualization

 The PHP-based web interface was implemented to present the extracted IF conditions
in an easy-to-navigate format. The interface allowed ISRO engineers to interact with
the data through a user-friendly dashboard.

18
 INTERNSHIP REPORT – URSC, ISRO

 Engineers could search for IF conditions by various attributes, including file name,
function name, or specific keywords. This provided a flexible and dynamic way to
filter through the large number of conditions and focus on areas of interest.

 The search functionality made it possible to locate complex or nested IF conditions

with ease. This was particularly valuable for reviewing critical decision-making logic
that could impact the satellite’s operations.

 The web dashboard also allowed engineers to export conditions to CSV format for
further analysis or use in test script development. This feature enabled the team to
efficiently transition from code analysis to the validation and testing phases, ensuring
that all decision-making logic was thoroughly evaluated.

19
 INTERNSHIP REPORT – URSC, ISRO

CHAPTER – 11
INTERNSHIP TIMELINE

Week Tasks Duration Challenges Faced

(Weeks)

Week 1 Familiarization with ISRO’s software and 1 Integration with

Understand toolChallenges in integrating Understand tool,
Python with Understand tool configuring environment

Week 2 Setting up the development 1 Limited

environmentResolving examples/documentation
dependenciesInitial trial and error with for Understand API
the Understand API

Week 3 Start writing Python scripts to extract IF 1 Understanding the

conditionsTesting and debugging structure of ADA code,
extraction logic handling initial
extraction errors

Week 4 Develop and refine 30+ Python 1 Complex logic for nested
scriptsHandle edge cases and nested IF and multi-line IF
conditions conditions

Week 5 Finalizing Python utilityTest on large 1 Final adjustments for

portions of the codebaseRefinement of large codebase
extraction logic compatibility

Week 6 Build and integrate PHP-based web 1 Web interface design

interfaceDesign layout and functionality and interactive elements
for displaying IF conditions

Week 7 Finalize web interfaceConduct user 1 Conducting user

testingComplete project documentation feedback testing and
and results presentation final refinements

20
 INTERNSHIP REPORT – URSC, ISRO

CHAPTER - 11
CONCLUSION
This internship project represents a significant step forward in automating the analysis and
testing of legacy ADA code at ISRO. The developed tools have laid the groundwork for future
efforts to streamline the validation and verification of satellite software, particularly in
critical subsystems like the Attitude and Orbit Control Electronics (AOCE).

11.1 Key Outcomes:

a. Centralized Decision-Making Logic:

o By extracting and centralizing all IF statements within the code, the utility
enables domain experts to easily locate and understand the key decision points
that drive the behavior of the satellite’s control systems. This provides a clearer
picture of how the software makes decisions and responds to various conditions,
which is essential for mission success.

b. Focused Validation of High-Risk Logic:

o The extracted IF conditions highlight potentially high-risk logic paths,

making it easier for engineers to focus their efforts on validating these critical
decision points. This focused approach improves the efficiency and accuracy of
the testing process, ensuring that potential software failures are identified and
addressed early.

c. Reduced Manual Effort:

o The tool significantly reduces the manual effort involved in reading through
large, complex codebases. Engineers no longer need to manually search through
hundreds or thousands of lines of code to identify IF conditions. Instead, they
can rely on the utility to do this quickly and accurately, freeing up time for
higher-level analysis and testing.

11.2. Web Interface and Collaboration:

The accompanying PHP-based web interface makes the extracted data easily accessible to
both software developers and testing teams. The interface allows for:

 Searchability and filtering, enabling users to quickly find specific conditions of

interest.

21
 INTERNSHIP REPORT – URSC, ISRO

 Interactive exploration of source code, making it easier to understand the context of

each decision point.

 Data export features, supporting test case generation and documentation.

This collaborative platform facilitates better communication between teams and accelerates the
overall software verification process.

11.3. Future Integration Potential:

This toolset is not just a one-time solution but a foundational step in improving ISRO’s long-
term software validation and verification processes. The ability to extract, visualize, and
interact with decision-making logic positions the tool to be integrated into ISRO’s formal
verification workflows for both heritage and future missions.

With further refinement and adoption, this utility can become a core component of ISRO's
efforts to ensure reliable and robust satellite software for upcoming space missions.

22
 INTERNSHIP REPORT – URSC, ISRO

REFERENCES
a. Internal ISRO Documentation on ADA Code Architecture

o Internal resources provided by ISRO detailing the structure and design of the ADA
code used in satellite subsystems, particularly the Attitude and Orbit Control
Electronics (AOCE) system, served as the primary reference for understanding
the context and functionality of the software.

b. SciTools Understand API Documentation

o The official documentation for Understand by SciTools was instrumental in

integrating the Understand API with Python. It provided crucial details on how
to interact with and extract relevant metadata from the .udb databases generated
from the legacy ADA code.

c. Open-Source PHP and JavaScript Libraries

o Various open-source libraries for PHP and JavaScript were used to enhance the
functionality and interactivity of the web interface. These libraries, such as
Bootstrap for responsive UI and custom JavaScript functions for searching and
sorting, were essential for building an efficient and user-friendly interface.

23