AI Integrated Blockchain for Autonomous Vehicles

Inspiration

The inspiration for the "Decentralized Autonomous Vehicles" (DAV) project stems from the growing advancements in autonomous vehicle technology and the potential benefits it can bring to transportation systems worldwide. The vision of a future where self-driving vehicles are seamlessly integrated into our daily lives sparked the idea to leverage blockchain technology to enhance their capabilities.

The inspiration also arose from recognizing the challenges that autonomous vehicles face when making real-time decisions in complex and dynamic environments. Factors like unpredictable weather conditions, traffic patterns, and road hazards can pose risks and require immediate adaptive responses. By implementing a decentralized network and leveraging the transparency and security features of blockchain, we aim to create a system where vehicles can share and learn from each other's experiences, ultimately improving decision-making and enhancing safety on the roads.

Furthermore, the concept of a decentralized network aligns with the core principles of blockchain technology, such as transparency, immutability, and security. By harnessing these properties, we seek to create an infrastructure that fosters collaboration, data sharing, and collective learning among autonomous vehicles. The decentralized nature of the DAV project also addresses concerns related to data privacy, security, and centralized control by empowering vehicles to make informed decisions while maintaining data integrity and protecting against unauthorized access.

Ultimately, the inspiration for the DAV project arises from the desire to build a future where autonomous vehicles operate in a decentralized and secure manner, leveraging the power of blockchain to enhance decision-making, improve safety, and create a more efficient and sustainable transportation ecosystem.

What it does

Decentralized Autonomous Vehicles is a network that will ultimately connect self-driving vehicles (such as cars, trucks, and drones etc..) to every vehicle on the Blockchain network, enabling them to make secure real-time decision making. By implementing decentralized nature from the blockchain we are enabling decentralized decision-making when there exist some environmental factors such as bad weather conditions, bad road conditions, traffic patterns etc., Once the vehicle will experience an incident and learns something from it, then the data learned from incident will be added to the ledger and made available to all other nodes in the network shared ledger so that other vehicles can make decisions based on the data provided. So that, all the vehicles connected to that decentralized shared ledger can learn automatically and make decisions from the experience of every single vehicle. A decentralized network connecting autonomous vehicles on the blockchain using Vehicular IoT (VIoT) and Vehicular Ad-hoc Network (VANET) technology. The system guarantees data security and privacy, transparency, traceability, and protection against unauthorized access or data tampering/destruction

How we built it

1 Created VIoT Vehicular IoT (VIoT) refers to the network of IoT devices and sensors installed in a self-driving car that collect and exchange data about the vehicle’s environment and performance.

1.1 Created Map(net) [nod +edg +type] The creation of the Map(net) in SUMO involves defining the topology of the road network, which is comprised of nodes and edges. Nodes are points in the network where edges connect, and edges represent the connections between nodes, or in other words, the road segments. To create the Map(net), you will need to define the nodes, edges, and types

Nodes: Nodes are defined using the tag and require an identifier as well as the X and Y coordinates of the node on the map. we have defined 15 nodes such as n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12, n13, n14, and n15 in Sumo, and saved this node information in a file with an extension of .nod.xml. The file is named Points.nod.xml.

Edges: Edges are defined using the tag and require an identifier, as well as the identifiers of the nodes that the edge connects. You can also specify the type of the edge, the number of lanes, and other parameters. We have defined the edges between nodes in our simulation, including connections such as n1n2, n2n3, n3n4, n5n6, n2n7, n7n8, n8n9, n9n10, n10n4, n2n11, n11n12, n12n13, n13n14, n14n5, n9n3, n3n12, and n14n15. These edges help to define the possible routes that the VIoT vehicles can take and allow us to simulate traffic flow in the network. The edge information is saved in a file with an extension of .edg.xml. The file is named Paths.edg.xml.

Types: Types are defined using the tag and represent the different types of edges in the network. You can specify parameters such as the number of lanes, the speed limit, and the priority. The two different types of edge types, 2L30 and 2L75, have been defined in the simulation, each with their own speed limit. These speed limits are used to calculate the time it takes for a vehicle to traverse the edge and can be used to determine the optimal route for the vehicle. The type information is saved in a file with an extension of .types.xml. The file is named as Types.type.xml. Once you have created the nod.xml, types.xml, and edg.xml files that define the nodes, edges, and types of your road network, you can use the netconvert tool to convert them into a .net.xml file that SUMO can use to simulate the network. To do this, follow these steps:

• Open the command prompt or terminal and navigate to the directory where your nod.xml, types.xml, and edg.xml files are saved.

• Run the netconvert command and specify the names of the three input files, as well as the name of the output file (which will be the .net.xml file). netconvert --node-files Points.nod.xml --edge-files Paths.edg.xml -t Types.type.xml -o Map.net.xml

• Once netconvert has finished, you should see a new file in your directory named "Map.net.xml". This is Map(net) file that we can use to simulate road network in SUMO.

1.2 Created Route (rou)

• In order to simulate vehicles on your road network, you need to define the routes that they will take. A route is simply a sequence of edges that the vehicle follows from its origin to its destination.

• Routes are defined using the tag. A route needs an identifier and a list of edges, which represents the path that the vehicle will follow. The edges are specified using the 'edges' attribute of the tag.

• We have carefully defined four distinct routes for our vehicles in Sumo simulation. For instance, veh0 follows the route0 that passes through n1n2, n2n3, n3n4, n4n5, and n5n6 edges. Similarly, veh1 takes the route1, which includes n1n2, n2n7, n7n8, n8n9, n9n10, n10n4, n4n5, and n5n6 edges. Veh2 follows the route2, which covers n1n2, n2n11, n11n12, n12n13, n13n14, n14n5, and n5n6 edges. Finally, veh3 takes the route3 that passes through n1n2, n2n3, n3n4, n4n5, and n5n6 edges. However, we have also encountered some obstacles on our way that we have defined in the n2n3 and n9n10 edges, which we need to overcome using smart contract functions to update the routes of the VIoT vehicles on the blockchain.

• Once you have defined your routes, you need to save them as .rou.xml files. You can create as many route files as you need, with each file containing one or more routes. We have saved the file as Route.rou.xml.

• Once you have defined your routes and saved them as .rou.xml files, you can use them in your SUMO simulations by specifying them as input to the simulation.

1.3 Created Sumo configuration [Map + Route]

• To create a SUMO configuration, you need to create a .sumocfg file. This file is an XML file that specifies the various parameters of your SUMO simulation, including the name of the road network file(Map.net.xml), the name of the route file(Route.rou.xml), and the duration of the simulation. sumo -c Sumo.sumocfg

• Once you have created your SUMO configuration file, you can run the simulation using the "sumo" command-line tool, specifying the name of the configuration file as an argument

• This will start the simulation and display the results in the console. You can also specify output files for the simulation, which will be generated at the end of the simulation and can be used to analyze the results.

2 Created local blockchain network [Ganache] Ganache is a personal blockchain for Ethereum development, which allows developers to create and test smart contracts and decentralized applications (dApps) on a local blockchain network. It is particularly useful for testing and development because it provides a sandbox environment that is isolated from the main Ethereum network, meaning that developers can experiment with their code without risking any real Ether or valuable data. Ganache provides a range of useful features, including the ability to create and manage Ethereum accounts, simulate different network conditions and scenarios, and inspect the blockchain and transaction histories in real-time. It also includes a built-in debugger that allows developers to step through their code line-by-line and analyze any errors or issues that may arise. In addition to its powerful features, Ganache is also very user-friendly and easy to set up. It can be installed quickly and easily on any operating system and integrates with many popular development frameworks and tools, including Truffle, Remix, and Web3.js.

2.1 Launched Ganache To launch Ganache, you can follow these simple steps:

• First, download and install Ganache from the official website.

• Once installed, open Ganache and you will be greeted by a clean and user-friendly interface.

• You can choose to either start a new workspace or open an existing one.

• In the workspace, you can customize various parameters, such as the number of accounts, the initial balance of each account, and the gas limit and price.

• You can also choose to import existing accounts or create new ones from scratch.

• Once you have configured your workspace, click on "Start" and Ganache will launch a local blockchain network on your machine.

Launching Ganache is an essential step for any Ethereum developer, as it provides a secure and isolated environment for testing and debugging smart contracts and dApps. With its intuitive interface and powerful features, Ganache is the perfect tool for anyone looking to develop on the Ethereum blockchain. By using Ganache, developers can experiment with their code without risking any real funds or data, making it an ideal choice for both beginners and experienced developers alike. So, whether you're building your first dApp or working on a complex smart contract, be sure to launch Ganache and take advantage of its many features and benefits.

2.2 Configured network settings (Hostname, port, network id) Configuring network settings in Ganache is a straightforward process. Here are the steps to follow:

• Open Ganache and start a new workspace or open an existing one.

• In the workspace settings, navigate to the "Server" tab.

• In the "Hostname" field, enter the IP address or domain name of the machine running the Ganache server. By default, this is set to "127.0.0.1", which is the loopback address for your local machine.

• In the "Port" field, enter the port number that Ganache will listen on for incoming connections. By default, this is set to "7545", but you can choose any available port.

• In the "Network ID" field, enter the unique identifier for your private network. This is important if you want to connect to other nodes or services on the same network. By default, this is set to "5777", but you can choose any non-zero positive integer. Once you have configured the network settings in Ganache, you can start your private blockchain and connect to it from your dApp or other Ethereum tools. Ganache makes it easy to experiment with different network configurations and settings, allowing you to finetune your network for maximum performance and security.

3 Run Chainlink node 3.1 Set up Chainlink node 3.1.1 Installed Docker: Visited the Docker website: https://www.docker.com/get-started . Downloaded and installed Docker for the operating system. Followed the on-screen instructions to complete the installation.

3.1.2 Set up a PostgreSQL database: Downloaded and installed PostgreSQL from the official website: https://www.postgresql.org/ . Noted the PostgreSQL username, password, and the port number during the installation.

3.1.3 Downloaded Chainlink Docker image: Opened a terminal or command prompt. Ran the command to download the Chainlink Docker image: docker pull smartcontract/chainlink:latest

3.1.4 Created a Docker network: Ran the command to create a Docker network: docker network create chainlink

3.1.5 Started the Chainlink node container: Ran the command to start the Chainlink node container: docker run -d --name chainlink-node -p 6688:6688 --network chainlink smartcontract/chainlink:latest local

3.1.6 Configured the Chainlink node: Opened a web browser and entered http://localhost:6688 to access the Chainlink UI. Followed the on-screen instructions to set up and configure the Chainlink node. Provided the necessary configuration details, such as the Ethereum node URL, database connection, and other settings as required.

3.2 Obtained Chainlink credentials 3.2.1 Visited the Chainlink website: Go to the Chainlink website (https://chain.link/) and either sign up for a new account or log in to your existing account.

3.2.2 Navigated to API Keys: Once logged in, navigate to the "API Keys" section or a similar area on the Chainlink website where you can generate API keys.

3.2.3 Generated a new API key: Click on the option to generate a new API key specific to your project. Provide any required details or permissions, if applicable, and generate the API key.

3.2.4 Noted down the API key and node URL: After generating the API key, make sure to note down the API key itself and the corresponding node URL. These credentials will be used to authenticate and interact with the Chainlink services from your application or smart contracts.

4 Deployed a smart contract into that Blockchain network 4.1 Wrote smart contract with chainlink keepers A smart contract is a self-executing program that runs on a blockchain network. It contains a set of rules and conditions that govern the execution of the contract. Smart contracts are typically written in Solidity, a programming language used specifically for Ethereum-based blockchain networks. The smart contract defines the logic and rules that govern a specific set of transactions on the network.

• We have written a smart contract to store and manage information related to vehicles in a decentralized manner on a blockchain network. It defines a struct to represent a vehicle and uses a mapping to store vehicle data by ID. The smart contract also provides functions to retrieve and update vehicle data.

• In that smart contract we have defined the struct with properties:

o id: a string to represent the unique identifier of the vehicle

o speed: an integer to represent the speed of the vehicle

o route: a dynamic array of strings to represent the path taken by the vehicle

o current_edge_id: a string to represent the current edge on which the vehicle is traveling

o route_index: an integer to represent the current index of the vehicle on the route

o next_edge: a string to represent the next edge on the vehicle's route

o next_edge_vehicles: a dynamic array of strings to represent the IDs of other vehicles traveling on the next edge

• We have defined mapping to store vehicle data by vehicle ID

• We have defined functions to retrieve and update the vehicle data by vehicle ID

o The checkSpeedAndRoute function is a Chainlink Keepers-specific function. It takes a vehicle ID as input and performs state changes based on a specific condition. If the vehicle's speed is zero and the next edge ID matches "n2n3", the route of the vehicle is updated to a predefined route.

•The contract implements two functions required by the Keeper interface:

o checkUpkeep: This function is called periodically by Chainlink Keepers to determine if upkeep is needed. The function returns a boolean value indicating whether upkeep is needed and an optional performData value.

o performUpkeep: This function is called by Chainlink Keepers when upkeep is needed. It takes performData as input, which can be decoded to extract the vehicle ID. In this case, the function calls checkSpeedAndRoute with the extracted vehicleID.

4.2 Connected Ganache with truffle Ganache is a personal blockchain network that allows developers to test and deploy their smart contracts. Truffle is a development framework for Ethereum-based blockchain networks that simplifies the process of building and deploying smart contracts. To connect Ganache with Truffle, we can follow these steps:

• Open command prompt or terminal and navigate to the directory where you want to create Truffle project.

• Run the command “truffle init” to initialize a new Truffle project.

• Once the project is initialized, navigate to the truffle-config.js file located in the root directory of the project.

• In the truffle-config.js file, configure our network settings by specifying the port number to match that of our Ganache instance and defining the accounts to use for deployment and testing, making it easy to seamlessly interact with our local blockchain network.

• Save the truffle-config.js file.

• Open Ganache and make sure it is running on port 7545, which is the default port for the Ganache GUI.

In summary, connecting Ganache with Truffle involves configuring a new network in the truffle-config.js file with the correct host, port, and network ID information for the Ganache network.

4.3 Compiled smart contract Compiling a smart contract is the process of translating the human-readable Solidity code into machine-readable bytecode that can be executed on the Ethereum Virtual Machine (EVM). When you run the “truffle compile” command, Truffle will look for all the Solidity files in your project's “contracts/” directory and its subdirectories. It will then compile each file individually, creating an ABI (Application Binary Interface) file and a bytecode file for each contract. The ABI file contains a description of the functions and events in the contract, which can be used by other programs to interact with the contract. The bytecode file is the actual executable code that will be deployed to the blockchain. During the compilation process, Truffle will also check for errors in your code, such as syntax errors or type mismatches, and will warn you if any are found. This can help catch bugs early and save time in the long run. Once the compilation is complete, Truffle will output the ABI and bytecode files for each contract, which can then be used to deploy the contract to a blockchain network.

4.4 Deployed smart contract Deploying a smart contract means publishing the compiled smart contract to a blockchain network so that it can be executed and accessed by users. In the context of Truffle, the deployment process involves creating a migration file that specifies the details of the smart contract deployment, such as the contract address, transaction hash, and the network on which it is deployed. To deploy a smart contract using Truffle, you first need to create a migration file inside the “migrations” directory. The file name should be in the format “n_deploy_contract.js”, where n is the migration order number. Inside the migration file, you need to use the deployer object to deploy the smart contract. The deployer object has a deploy function that takes the contract's compiled artifact as an argument and deploys it to the specified network. Once the contract is deployed, you can access its address using the address property of the deployed instance. After creating the migration file, you can deploy the smart contract by running the “truffle migrate” command. Truffle will automatically detect new migration files and execute them in the order they were created. Once the deployment process is complete, Truffle will display the contract address, transaction hash, balance, gas used and gas price on the console. It's important to note that when deploying a smart contract, you need to specify the network on which it will be deployed. This can be done by setting the network property in the truffle-config.js file. Additionally, you may need to specify the account that will be used to deploy the contract if you are working with a private network or a test network.

5 Decision making 5.1 Decision making using Python Script 5.1.1 Connected Python script with ganache network using web3 API Ganache is a personal blockchain for Ethereum development, and web3.js is a collection of libraries that allow you to interact with a local or remote Ethereum node using JavaScript. To connect Python with Ganache network, we can use the web3.py library, which is a Python implementation of web3.js

• Install web3.py library

• Import web3

• Connect to ganache: To connect to Ganache network, you need to create an instance of the Web3 class and pass the HTTP provider URL of the Ganache network as a parameter.

• Check connection: You can check if the connection to Ganache is successful by calling the isConnected() function on the web3 instance.

• Interact with Ganache: Once you are connected to Ganache, you can use the web3.py library to interact with the network. For example, you can get the accounts on the Ganache network by calling the eth.accounts property on the web3 instance. These are the basic steps to connect a Python script with Ganache network using web3.py. You can use the same approach to interact with the blockchain on the Ganache network and update/retrieve VIoT vehicle data using smart contract functions.

5.1.2 Got individual VIoT vehicle data using Traci. Traci (Traffic Control Interface) is a powerful tool for traffic simulation, which can be used to simulate traffic scenarios and control the movement of vehicles in a traffic network. To get individual VIoT vehicle data using Traci, you would typically follow these steps:

• First, you would need to set up a traffic scenario using a traffic network file in SUMO (Simulation of Urban Mobility), which is a widely-used traffic simulation software.

• Next, you would create a Python script to interact with the traffic simulation using Traci. This script would typically initialize the simulation, connect to the simulation using Traci, and control the movement of vehicles in the traffic network.

• You can then use Traci to retrieve data for individual VIoT vehicles in the traffic network. This might include data such as the current speed of the vehicle, its location, the current route it is following, and any other relevant data that you need.

• Once you have retrieved the relevant data, you can use it to make decisions about how to update the VIoT vehicle's behavior, such as adjusting its speed or changing its route.

• In order to integrate Traci with your VIoT project, you would need to ensure that the data you retrieve from Traci is compatible with the format and requirements of your smart contract on the blockchain network.

5.1.3 Updated VIoT vehicle data to the local blockchain network using smart contract functions.

• To update VIoT vehicle data to the local blockchain network using smart contract functions, first you need to write and deploy a smart contract that can accept VIoT vehicle data and update it on the blockchain. You can then use web3.js and web3.py to interact with the smart contract from your Python script.

• Then Instantiate the smart contract using the contract's address and ABI (Application Binary Interface) in your Python script.

• Call the smart contract function that updates the VIoT vehicle data by passing the necessary parameters. The transaction will be sent to the local blockchain network for processing.

• Wait for the transaction to be mined and confirmed on the blockchain. You can use web3.py to monitor the transaction status. By following these steps, you can update VIoT vehicle data on the local blockchain network using smart contract functions.

5.1.4 Retrieved VIoT vehicle data using smart contract functions Retrieving VIoT vehicle data using smart contract functions involves querying the blockchain for the specific data that you want to retrieve. This requires that you know the address of the smart contract containing the data, as well as the function that you need to call to retrieve the data. Once you have this information, you can use a web3.js library to interact with the smart contract and retrieve the data. The specific function that you call will depend on the data that you want to retrieve. For example, if you wanted to retrieve the speed of a particular VIoT vehicle, you would need to call the function in the smart contract that returns that specific piece of data. After calling the function, the smart contract will execute the function code and return the requested data to your Python script. You can then use this data to update your application or make decisions based on the retrieved data.

5.2 Decision making using Chainlink keepers 5.2.1 Configured a Chainlink job on the Chainlink node: Defined a job on the Chainlink node that corresponds to the desired decision-making logic. Specified the required input data, execution frequency, and other relevant parameters. Implemented the performUpkeep function in the job definition to be called by Chainlink Keepers.

5.2.2 Built and sent a Chainlink request to the oracle address: Constructed a Chainlink request in the smart contract or off-chain application. Specified the job ID, desired payment, and any input data necessary for the decision-making process. Sent the Chainlink request to the specified oracle address in the job configuration.

5.2.3 Monitored and handled Chainlink job callbacks: Implemented a callback function in the smart contract or off-chain application to handle the response from Chainlink Keepers. The callback function was triggered when the performUpkeep function executed and provided a response. Processed the response received from Chainlink Keepers inside the callback function and made decisions based on the outcome.

5.2.4 Implemented decision-making logic in the performUpkeep function: Wrote the decision-making logic inside the performUpkeep function in the job definition. Retrieved data from external sources, performed calculations, or executed specific actions based on predefined conditions. Ensured the decision-making process was implemented securely, efficiently, and accurately.

6 Testing Working on a local blockchain network involves setting up a blockchain network on a local machine or server for testing and development purposes. This is typically done using a blockchain development framework such as Ganache or Truffle, which allows for the creation of a private, local blockchain network that can be used to test smart contracts and other blockchain applications without incurring the cost or complexity of a public blockchain. Deploying a smart contract on a local blockchain network is a great way to test and refine the functionality of the system before moving to a larger, private blockchain network. By starting with a local network, you can easily monitor and troubleshoot any issues that arise, without worrying about the complexities of a larger, more distributed network. Once you are satisfied with the performance and security of your smart contract and the local network, it may be time to transition to a private blockchain network. Working on a local blockchain network also allows for easier collaboration between developers, as the network can be easily replicated and shared among team members. Additionally, it provides a sandbox environment for experimentation and innovation, allowing developers to try out new ideas and approaches without risking real-world consequences. However, it's important to note that deploying a smart contract on a local blockchain network is not the same as deploying it to a public or private blockchain network. While a local network can provide a good testing environment, it may not accurately reflect the security, scalability, or performance of a live blockchain network. Therefore, it's important to thoroughly test and validate smart contracts before deploying them to any blockchain network.

Challenges we ran into

Throughout our project on AI integrated blockchain for autonomous vehicles, we encountered various challenges that tested our perseverance and problem-solving abilities. One major hurdle was the lack of built-in support for Chainlink services in Ganache, necessitating the connection of our Ganache-based smart contracts to external Chainlink nodes to utilize Chainlink services such as Keepers, API calls, data feeds, or VRF.. Additionally, we faced the difficulty of finding comprehensive and reliable sources specific to our project, requiring extensive research and exploration.

Despite these challenges, we remained determined and committed to the project's success. We invested countless sleepless days and nights into overcoming the obstacles we encountered. Our team conducted thorough research, delving into academic papers, industry reports, and related projects to adapt existing knowledge to our use case. We actively engaged with experts, peers, and online communities to seek guidance and exchange ideas.

By maintaining our commitment to learning and problem-solving, we successfully navigated the limited available sources and delivered a robust AI integrated blockchain solution for autonomous vehicles. The project not only expanded our understanding of the subject matter but also honed our resourcefulness and critical thinking skills.

Overall, our journey involved both technical and research-oriented challenges, which we tackled with determination and dedication. Overcoming these hurdles has not only contributed to the project's success but has also equipped us with invaluable skills for future endeavors in the field of AI integrated blockchain for autonomous vehicles.

Accomplishments that we're proud of

Throughout the development of the "Decentralized Autonomous Vehicles" (DAV) project, we have achieved several significant accomplishments that we are proud of. These accomplishments demonstrate our commitment to innovation, technical expertise, and addressing real-world challenges in the transportation industry. Here are some of our key achievements:

1 Successful Integration of Blockchain and Autonomous Vehicles: We have successfully integrated blockchain technology with autonomous vehicles, creating a decentralized network that enables secure and real-time decision-making. This accomplishment required in-depth research, technical expertise, and collaboration between blockchain developers and autonomous vehicle experts.

2 Implementation of Vehicular IoT (VIoT) and VANET with Blockchain: We have effectively implemented Vehicular IoT and Vehicular Ad-hoc Network (VANET) technologies to facilitate communication and data exchange among autonomous vehicles within the DAV network. This achievement required designing robust communication protocols and ensuring data security and privacy.

3 Development of a Secure and Transparent System: We have created a system that guarantees data security, privacy, transparency, traceability, and protection against unauthorized access or data tampering/destruction. By leveraging the immutable nature of blockchain, we ensure the integrity and authenticity of the data shared among autonomous vehicles.

4 Validation of Decentralized Decision-Making: Through rigorous testing and simulations, we have validated the effectiveness of decentralized decision-making within the DAV network. Our system enables vehicles to learn from real-world incidents and make informed decisions based on shared knowledge, ultimately improving safety and adaptability in complex environments.

5 Successful Integration of Chainlink Oracles: One of our key achievements is the seamless integration of Chainlink oracles into our AI integrated blockchain for autonomous vehicles. This integration has enabled our system to securely and reliably access real-time external data, enhancing the decision-making capabilities of autonomous vehicles. By leveraging Chainlink's robust and decentralized oracle network, we have achieved a high level of data accuracy and timeliness, ensuring the effectiveness and reliability of our autonomous vehicle ecosystem.

What we learned

During the development of the "Decentralized Autonomous Vehicles" (DAV) project, my teammate and I not only gained technical knowledge but also learned important lessons related to teamwork, the autonomous industry, Vehicular IoT (VIoT), Vehicular Ad-hoc Network (VANET), and the integration of Chainlink. Here's an overview of what we learned:

1 Teamwork: Collaborating with my teammate throughout the project allowed us to leverage each other's strengths, share responsibilities, and effectively communicate ideas and progress. We learned the importance of clear and frequent communication, division of tasks, and supporting each other to achieve our shared goals.

2 Autonomous Industry: Through research and development, we deepened our understanding of the autonomous industry and its potential impact. We studied the latest trends, challenges, and advancements in self-driving vehicles, including the use of blockchain technology for secure decision-making and data sharing. This knowledge enabled us to design a solution that addresses real-world industry needs.

3 Vehicular IoT (VIoT): We explored the concept of Vehicular IoT, which focuses on the integration of vehicles into the broader Internet of Things ecosystem. We learned about the unique challenges and opportunities presented by VIoT, including the secure communication and data exchange between vehicles and their environment. This understanding influenced our design choices and solution architecture.

4 Vehicular Ad-hoc Network (VANET): VANET technology played a crucial role in our project. We familiarized ourselves with VANET protocols and communication mechanisms that enable vehicles to form an ad-hoc network for exchanging data and information. We learned about the benefits of VANET, such as improved traffic management and enhanced safety through vehicle-to-vehicle (V2V) and vehicle-to-infrastructure (V2I) communication.

5 Integration of Chainlink: As part of our project, we integrated Chainlink, a decentralized oracle network, to enhance the capabilities of our decentralized decision-making system. We learned about the importance of real-world data inputs for autonomous vehicles and how Chainlink enables secure and reliable access to off-chain data sources. Integrating Chainlink allowed us to leverage external data and services in a decentralized manner, enhancing the decision-making capabilities of our autonomous vehicles.

6 Industry Integration: The integration of Chainlink into our project exposed us to the practical application of blockchain technology and oracles in the autonomous industry. We gained insights into how blockchain can facilitate decentralized decision-making, data sharing, and secure transactions among autonomous vehicles. This knowledge broadened our perspective on the potential impact of blockchain in transforming the autonomous industry.

7 Interdisciplinary Skills: Developing the DAV project required us to combine knowledge and skills from various disciplines, including blockchain, autonomous vehicles, IoT, networking, and oracles. We learned how to bridge these domains and integrate technologies seamlessly to create a comprehensive solution. This interdisciplinary approach helped us develop a holistic understanding of the challenges and opportunities in the field.

By combining our teamwork, understanding of the autonomous industry, knowledge of VIoT and VANET technologies, and integration of Chainlink, we successfully developed a decentralized decision-making system for autonomous vehicles. These experiences not only enhanced our technical skills but also prepared us for future endeavors in the autonomous industry and emerging technologies.

What's next for AI Integrated Blockchain for Autonomous Vehicles

Our next steps involve real-world deployment, scaling and network expansion, enhanced security and privacy, further integration with Chainlink oracles, collaboration and partnerships, continuous improvement, and community engagement. By pursuing these avenues, we aim to advance the field of decentralized decision-making for autonomous vehicles and contribute to the realization of a safer, more efficient, and decentralized autonomous industry. Additionally, as students working on this project, we are actively searching for good opportunities in companies that are involved in the development of AI integrated blockchain for autonomous vehicles. We are eager to join organizations that align with our project's vision and are actively working on innovative solutions in this field. We believe that by joining a forward-thinking company, we can leverage their resources, knowledge, and industry experience to further enhance our project and contribute to groundbreaking advancements in the industry. We are enthusiastic about exploring potential job opportunities and would be delighted to connect with our dream companies like chainlink that are at the forefront of AI integrated blockchain for autonomous vehicles. If you are a company seeking talented individuals with a passion for this field, we would be thrilled to engage in discussions and explore how we can contribute to your organization's success.