ACKNOWLEDGEMENT:

I wish to express my profound gratitude to my

teacher, Mr. Mujibullah, our Senior Principal, Mrs.
Nimitha Pramod, Principal, Mrs. Sheeja Saleem,
and Vice Principal, Mrs. Radhika Bhojan, for their
invaluable support and encouragement throughout
my project on the Toll Booth Management System.
This project has provided me with an excellent
opportunity to learn and conduct research on
Python coding.
I also extend my heartfelt thanks to my colleagues
and friends for their insightful suggestions,
constructive feedback, and unwavering support, all
of which have greatly contributed to the success of
this project.
Finally, I am deeply grateful to my family for their
constant love, motivation, and encouragement.
Their unwavering support has been a crucial
driving force in the successful completion of this
endeavor.
 INDEX
S.NO TITLE PAGE NO.

1. INTRODUCTION

2. SCOPE AND OBJECTIVE OF TBMS

3. PYTHON IDLE

4. STRINGS, LISTS, TUPLES, DICTIONARIES

5. HARDWARE AND SOFTWARE USED

6. SOURCE CODE

7. OUTPUT

8. USER MANUAL

9. CONCLUSION

10. BIBLIOGRAPHY
 INTRODUCTION
A toll booth management system (TBMS) is used to collect
fees from vehicles using certain roads, bridges, or tunnels. It
helps manage traffic flow, maintain infrastructure, and fund
road repairs and improvements. The system typically involves
automated or manual payment collection, ensuring that users
contribute to the upkeep of the facilities they use.

KEY FEATURES:
1.​Identifies the type of vehicle.
2.​The amount is calculated according to the type of
vehicle.
3.​The vehicle number is noted.
4.​Bill is produced stating the following.
The key modules of a Toll Booth Management System:
1.​Vehicle Entry/Exit Management: Tracks vehicle entry,
exit, and details (e.g., license plate, time).
2.​Payment Processing: Handles toll fee collection through
various payment methods (cash, card, RFID).
3.​Fee Calculation: Calculates tolls based on vehicle type,
distance, and time.
4.​Vehicle Classification: Identifies vehicle types to apply
appropriate toll charges.
5.​Data Reporting/Analytics: Generates reports on traffic,
revenue, and system performance.
SCOPE AND OBJECTIVE OF TBMS:

The scope of a Toll Booth Management System

includes automating toll fee collection through methods
such as RFID, smart cards, and online payments, while
also managing traffic flow at entry and exit points to
reduce congestion. It ensures accurate revenue
management by calculating toll fees correctly and
provides seamless user account management for
frequent travelers. The system also focuses on
maintenance and monitoring, offering real-time alerts
for any issues. The objective of this system is to
enhance efficiency by minimizing delays, improving
accuracy in toll collection, reducing operational costs
through automation, ensuring security to prevent fraud,
and generating valuable data and reports for better
traffic management and decision-making.
A toll booth helps constructors by generating revenue
that can be used to fund the construction, maintenance,
and repair of roads, bridges, or tunnels. It ensures a
sustainable source of funding for infrastructure projects,
helping maintain and improve the facilities over time.
 PYTHON IDLE
Python IDLE (Integrated Development and Learning
Environment) is a simple and user-friendly interface that
allows developers to write, test, and debug Python code. It
comes pre-installed with Python and provides essential
features like a text editor, interactive shell, and debugging
tools. IDLE is especially useful for beginners as it offers a
straightforward environment to experiment with code, run
scripts, and quickly view outputs without the need for
complex setup or configuration.

Python IDLE offers several advantages:

1.​User-Friendly Interface: It provides an easy-to-use
environment for beginners, with a simple text editor
and an interactive shell for immediate feedback.
2.​Pre-installed: IDLE comes bundled with Python, so
there is no need for additional installation or setup.
3.​Debugging Tools: It includes basic debugging
features, such as breakpoints and step-by-step
execution, making it easier to find and fix errors.
4.​Cross-Platform Compatibility: IDLE works across
different operating systems, including Windows,
macOS, and Linux.
 5.​Quick Testing: It allows for fast experimentation with
code snippets in the interactive shell, making it ideal
for learning and small projects.

Python IDLE, while useful, has some disadvantages:

1.​Limited Features: Compared to more advanced
IDEs, IDLE lacks features like code auto-completion,
advanced debugging tools, and built-in version
control.
2.​Not Ideal for Large Projects: IDLE is not
well-suited for large-scale applications due to its lack
of project management and organizational features.
3.​Basic User Interface: The interface is simple but
lacks customization options and modern features
found in other IDEs.
4.​Limited Support for External Libraries: IDLE does
not offer advanced integration or support for external
libraries and frameworks, limiting its usefulness for
more complex tasks.
5.​Lack of Advanced Performance Tools: It doesn’t
have advanced profiling or performance analysis
tools, which help optimize larger codebases.
 STRINGS
In Python, strings are sequences of characters enclosed in
single (' ') or double (" ") quotes. They are immutable,
meaning their content cannot be changed once created. Python
offers a variety of methods for working with strings, such as
concatenation, slicing, and formatting. Built-in functions like
len() return the length of a string, while methods like upper()
and lower() allow for case conversion. Strings also support
escape sequences, such as \n for a newline or \t for a tab,
enabling easy text formatting.

LISTS

In Python, lists are ordered collections that can hold a variety

of data types, including integers, strings, and even other lists.
Lists are mutable, meaning their elements can be changed,
added, or removed after creation. They are defined using
square brackets, with elements separated by commas. Python
provides several built-in methods for list manipulation, such
as append(), remove(), and pop(). Lists also support indexing,
slicing, and iteration, making them a versatile and essential
data structure for many programming tasks.
 TUPLES
Tuples are ordered collections of elements, similar to lists, but
unlike lists, they are immutable, meaning their contents
cannot be modified after creation. Tuples are defined using
parentheses () with elements separated by commas. They can
store elements of different data types, including numbers,
strings, and even other tuples. Tuples support indexing,
slicing, and iteration, but do not offer methods for
modification like lists. Due to their immutability, tuples are
often used for storing fixed data and are generally faster than
lists for certain operations.

DICTIONARIES
Dictionaries are unordered collections of key-value pairs,
where each key is unique and maps to a specific value. They
are defined using curly braces {} with each key-value pair
separated by a colon :. Values can be of any data type, while
keys must be immutable (e.g., strings, numbers, or tuples).
Dictionaries are highly efficient for lookups, as values are
accessed via keys. Common methods include get(), keys(),
and values(), allowing easy retrieval of values, keys, or both.
Dictionaries are widely used for fast data retrieval and for
representing structured data.
HARDWARE USED:

OS Name: Microsoft Windows 11

System Manufacturer: ACER
System Model: ACER Predetor helios 16
System Name: LAPTOP-7IPM9CSD
RAM:16.OOGB
OS Manufacturer: Microsoft Corporation

SOFTWARE USED:
Windows Python 3.12.0 64Bit

SOURCE CODE:

# Function to calculate the toll fee based on the vehicle

type
def calculate_amount(vehicle_type):
if vehicle_type == "Car":
return 100 # Car toll fee is Rs. 100
elif vehicle_type == "Bike":
return 50 # Bike toll fee is Rs. 50
elif vehicle_type == "Bus":
 return 200 # Bus toll fee is Rs. 200
elif vehicle_type == "Truck":
return 150 # Truck toll fee is Rs. 150
else:
return 0 # If vehicle type is unknown, no fee

# Function to print the bill

def print_bill(vehicle_number, vehicle_type, amount):
print("\n---- TOLL BILL ----")
print(f"Vehicle Number: {vehicle_number}")
print(f"Vehicle Type: {vehicle_type}")
print(f"Amount to Pay: Rs. {amount}")
print("--------------------")

# Function to collect vehicle data and calculate toll fee

def collect_vehicle_data():
# Get the vehicle number from the user
vehicle_number = input("Enter the vehicle number:
")

# Get the vehicle type from the user

print("Enter the type of vehicle (Car, Bike, Bus,
Truck): ")
vehicle_type = input().capitalize() # Capitalize the
first letter of the input to handle case sensitivity
 # Check if the vehicle type is valid
while vehicle_type not in ["Car", "Bike", "Bus",
"Truck"]:
print("Invalid vehicle type entered! Please enter
one of the following: Car, Bike, Bus, Truck.")
vehicle_type = input("Enter the type of vehicle
(Car, Bike, Bus, Truck): ").capitalize() # Re-enter

# Calculate the toll fee for the given vehicle type

amount = calculate_amount(vehicle_type)

return vehicle_number, vehicle_type, amount

# Function to ask the user if they want to continue

entering more vehicles
def continue_entry():
choice = input("Do you want to enter another
vehicle? (yes/no): ").lower()
while choice not in ['yes', 'no']:
print("Invalid input! Please type 'yes' or 'no'.")
choice = input("Do you want to enter another
vehicle? (yes/no): ").lower()
return choice == 'yes'

# Main function to manage the toll system

def main():
 print("Welcome to the Toll Management System!")

total_amount = 0 # Variable to keep track of the total

amount

while True:
# Collect data for each vehicle
vehicle_number, vehicle_type, amount =
collect_vehicle_data()

# Display the bill for the vehicle

print_bill(vehicle_number, vehicle_type, amount)

# Add the amount to the total

total_amount += amount

# Ask if the user wants to enter another vehicle

if not continue_entry():
break

# Final total amount

print("\n---- FINAL BILL ----")
print(f"Total Amount Collected: Rs.
{total_amount}")
print("Thank you for using the Toll Management
System!")
 print("--------------------")

# Call the main function to start the program

if __name__ == "__main__":
main()

Breakdown of the Code:

1.​calculate_amount: Calculates the toll fee based on
the vehicle type.
2.​print_bill: Prints the detailed bill for each vehicle.
3.​collect_vehicle_data: Prompts the user to enter
vehicle details and validates the vehicle type.
4.​continue_entry: Asks if the user wants to enter
another vehicle or not.
5.​main: The main function that runs the toll system,
collects vehicle data, prints the bills, and calculates the
total amount.

OUTPUT
Welcome to the Toll Management System!
Enter the vehicle number: AB1234
Enter the type of vehicle (Car, Bike, Bus, Truck): Car

---- TOLL BILL ----

Vehicle Number: AB1234
Vehicle Type: Car
Amount to Pay: Rs. 100
--------------------

Do you want to enter another vehicle? (yes/no): yes

Enter the vehicle number: XY5678
Enter the type of vehicle (Car, Bike, Bus, Truck): Bus

---- TOLL BILL ----

Vehicle Number: XY5678
Vehicle Type: Bus
Amount to Pay: Rs. 200
--------------------

Do you want to enter another vehicle? (yes/no): no

 ---- FINAL BILL ----
Total Amount Collected: Rs. 300
Thank you for using the Toll Management System!
--------------------

USER MANUAL

The provided code implements a simple toll management

system in Python that calculates and collects toll fees
based on the vehicle type. The program asks the user to
input the vehicle number and type (Car, Bike, Bus, or
Truck). It then calculates the toll fee using the
calculate_amount function, which assigns a specific
fee for each vehicle type and prints the toll bill using the
print_bill function. The system continues to prompt
users to enter data for additional vehicles while
accumulating the collected toll fees. To ensure data
accuracy, the program validates the vehicle type input and
handles errors when invalid types are entered. After
processing each vehicle, the user is asked if they want to
continue entering data. Once the user decides to stop, the
total amount collected is displayed as the final bill. The
system ensures a smooth user experience by repeatedly
checking for correct inputs and handling potential errors.
The program is flexible enough to allow for additional
 vehicle types or other enhancements such as database
storage or advanced reporting features.

CONCLUSION
In conclusion, the toll management system implemented in the
provided code efficiently handles the collection of toll fees based
on vehicle types, while ensuring accurate billing and total fee
calculation. The system is user-friendly, guiding the operator
through the input process and validating data to prevent errors.
With a simple and clear structure, it is effective for basic toll
operations and can be further extended or optimized to meet more
complex needs. Whether it's for a small-scale toll booth or a
starting point for larger systems, the code provides a solid
foundation for automating toll collection and tracking, ensuring
smooth operations and improved efficiency. Future enhancements
could include features like transaction history, database
integration, or dynamic pricing, depending on system
requirements.

FUTURE IMPLEMENTATIONS
For future implementation, the toll management system could be
enhanced with several features to improve efficiency and
scalability. These include dynamic pricing based on time or traffic
conditions, integration with Electronic Toll Collection (ETC)
 systems, and the use of Automatic Number Plate Recognition
(ANPR) for automatic vehicle identification. Adding reporting
and analytics tools, multi-lane management, and support for
various payment methods would further streamline operations.
AI-based vehicle classification, a graphical user interface (GUI),
and cloud storage integration would improve user experience and
data management. Additionally, security enhancements, real-time
monitoring, and mobile apps for users could make the system
more secure, user-friendly, and adaptable for future smart road
infrastructure.

BIBLIOGRAPHY
W3schools:
https://www.w3schools.com/python/

GeeksforGeeks:
https://www.geeksforgeeks.org
 Udemy:
https://www.udemy.com